There are two categories of tests:

1.  Tests of assignment.  These test the scaffolding code for assignment.
They test whether the = operator puts everything returned by its
children in the right place.  They also test whether each of the types
of lvalues returns the right sort of values.

2.  Tests of the instrumentation.  Have the right tests been written?
These are more straightforward.


			ASSIGNMENT TESTS

Because I am rather nervous about this code, these tests should be
more exhaustive than might otherwise be the case.

SET 1:

These all begin "s." for "scaffolding", e.g., s.id.c, s.arrayref.c


Conditions to combine:

left child is simple (a variable)
left child is complex

left child has tests.
left child has no tests (currently always the case).

left child lvalue is simple (a variable)	(follows from child being 
left child lvalue is complex (a whole tree)	 simple)

right child is simple.
right child is complex.

right child has tests
right child has no tests.

assignment has tests.
assignment has no tests.

TESTS:				

LEFT SIMPLE	Left Tests	Right Simple	Right Tests	Asgn Tests
1		1		1		1		1
1		1		1		1		0
1		1		1		0		1
1		1		1		0		0
1		1		0		1		1
1		1		0		1		0
1		1		0		0		1
1		1		0		0		0
1		0		1		1		1
1		0		1		1		0
1		0		1		0		1
1		0		1		0		0
1		0		0		1		1
1		0		0		1		0
1		0		0		0		1
1		0		0		0		0
0		1		1		1		1
0		1		1		1		0
0		1		1		0		1
0		1		1		0		0
0		1		0		1		1
0		1		0		1		0
0		1		0		0		1
0		1		0		0		0
0		0		1		1		1
0		0		1		1		0
0		0		1		0		1
0		0		1		0		0
0		0		0		1		1
0		0		0		1		0
0		0		0		0		1
0		0		0		0		0

USE THESE AS FOLLOWS:
1.  Each case must be present in some s.*.c.  (covered by s.id.c and s.array.c)
2.  For each lvalue type, its tests must cover all 4 relevant combinations
    in the first two categories.
3.  No temporaries used before being set.
4. 	correct "previous" value of left-side preserved for instrumentation.
	correct "new" value of left-side preserved for instrumentation.
	correct value of expression available.
	No repeated evaluation (where possible).

		INSTRUMENTATION TESTS (b.simple.c, b.plus.c, etc.)


Test with nested assignments:
	on left (must be embedded within, say, an array reference).
	on right

Check:
	lint:  no temporaries used before set.
	Previous value used where appropriate.
	New value used where appropriate.
	No repeated evaluation (where possible).
	correct value of expression available.


cases where instrumentation is on/off are tested in s. tests.

	
