Modulo-20 Test
The test consists of writing into an interval of 20 memory locations for each block with a pattern and filling all other
locations with its complement 6 times. Unlike the other tests, the Modulo-20 test is not affected by buffering or
caching, so it is able to detect most of the Stuck-At Faults, Coupling Faults, Transition Faults and Read Random
Faults that are not detected by other testing approaches.
Moving Inversions 8Bit Test
The test consists of filling the memory with the 8-bit wide pattern: 10000000 and then checking that the pattern
was correctly written. When checking, it writes the pattern’s binary complement (01111111) and checks it again.
The procedure described earlier is repeated 8 times, one for each pattern right shifted: 10000000, 01000000,
00100000, 00010000, 00001000, 00000100, 00000010, 00000001.
Moving Inversions 32 Bit Test
This test fills all the accessible memory with a shifting pattern, that is, a value which is binary left shifted as it is
written out through the accessible memory of every memory block. Once the pattern reaches 0x80000000 (a value
with the left most bit set to 1 only) then the pattern is reset to 0x00000001. After that, it checks the written values
and writes their binary complements, starting from the first memory address to the last one. Finally, the algorithm
checks the memory for the complements written in the previous step, being this checking starting from the last
element down to the first one. Such process is repeated 2 times. This test presents a more thorough approach
intended to cover most of the Stuck-At Faults and Transition Faults and some cases of Coupling Faults and Read
Random Faults...
Random Pattern Test
The test consists of filling the memory with a random generated pattern and then checking that the pattern was
correctly written. When checking, it writes the pattern's binary complement and checks it again. This process is
repeated twice. By default, 50 random patterns are used, therefore the test runs once for each of these patterns...
Random Number Sequence Test
The test consists of filling the memory with one different random generated pattern for each memory address and
then checking that the pattern was correctly written. In order to check it, the test must generate these numbers
based on a seed that may be reset to reproduce the sequence. When checking, it writes the pattern's binary
complement and it checks again. Such process is repeated several times. This test is intended to cover most of the
Stuck-At Faults. Coupling Faults, and some cases of Transition Faults and Read Random Faults.
Block Move Test
The test consists of moving memory data around within memory blocks. It repeats the movements described above
80 times. Finally, the test checks every memory address to verify if it is consistent.
Nibble Move Test
This test consists of writing to a nibble (a nibble is a group of four bits) a pattern value in each memory address,
then it validates every nibble individually. It repeats this process until all nibbles in every address are checked.