address each time such pattern is shifted. Therefore, the test is intended to cover most of the Stuck-At Faults and
some cases of Coupling Faults, and also testing the data bus by confirming that every bit can be written.
Walking Ones Right Test
The Walking Ones Right Test consists of writing a pattern where only the leftmost bit is set (e.g. 10000000), then
shift this pattern to the right (e.g. 01000000) until the end of the size of a byte, writing it again at the same memory
address each time such pattern is shifted. Therefore, such test is intended to cover most of the Stuck-At Faults and
some cases of Coupling Faults, and also testing the data bus by confirming that every bit can be written.
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