1 files changed, 129 insertions, 0 deletions

diff --git a/private/ntos/rtl/alpha/tmovmem.c b/private/ntos/rtl/alpha/tmovmem.c
new file mode 100644
index 000000000..3b381d9ba
--- /dev/null
+++ b/private/ntos/rtl/alpha/tmovmem.c
@@ -0,0 +1,129 @@
+/*++
+
+Copyright (c) 1993  Digital Equipment Corporation
+
+Module Name:
+
+    tmovmem.c
+
+Abstract:
+
+    This module implements a test of the operation of the RtlMoveMemory
+    function by running an exhaustive test of every case of string offset,
+    move length, and relative overlap of the two strings up to and a little
+    beyond one 32-byte cache line. This represents several hundred thousand
+    test cases. It is assumed any bugs that exist will be found within this
+    range. If only the error count summary is desired, type "tmovmem > nul"
+    instead.
+
+Author:
+
+    Thomas Van Baak (tvb) 13-Jan-1993
+
+Environment:
+
+    User mode.
+
+Revision History:
+
+--*/
+
+#include <nt.h>
+#include <ntrtl.h>
+#include <stdio.h>
+#include "localrtl.h"
+
+//
+// Two strings are defined within a large buffer. The target string is
+// initially below the source string with a small gap between the two
+// strings. A margin around the strings ensures any bytes accidentally
+// changed outside the strings are detectable. As the length of the strings
+// and the offset of the source string are varied, the target string wanders
+// from well below, through, and well above the source string.
+//
+
+#define MIN_OVERLAP (-(MAX_LENGTH + MAX_MARGIN))
+#define MAX_OVERLAP (MAX_LENGTH + MAX_MARGIN - 1)
+
+#define BUFFER_SIZE (MAX_MARGIN + MAX_LENGTH + MAX_MARGIN + MAX_OFFSET + MAX_LENGTH + MAX_MARGIN + MAX_LENGTH + MAX_MARGIN)
+
+UCHAR Buffer0[BUFFER_SIZE];
+UCHAR Buffer1[BUFFER_SIZE];
+UCHAR Buffer2[BUFFER_SIZE];
+
+void
+_CRTAPI1
+main()
+{
+    ULONG ErrorCount;
+    ULONG Length;
+    ULONG Offset;
+    LONG Overlap;
+    ULONG Result;
+    ULONG Source;
+    ULONG Target;
+    ULONG TestCases;
+
+    fprintf(stderr, "Testing RtlMoveMemory\n");
+    ErrorCount = 0;
+    TestCases = 0;
+
+    //
+    // Make a call to RtlMoveMemory for all possible source string offsets
+    // within a cache line, for a large set of string lengths, and a wide
+    // range of positions of the target string relative to the source string,
+    // including all possible overlapping string configurations.
+    //
+
+    for (Offset = 0; Offset <= MAX_OFFSET; Offset += 1) {
+        for (Length = 0; Length <= MAX_LENGTH; Length += 1) {
+            for (Overlap = MIN_OVERLAP; Overlap <= MAX_OVERLAP; Overlap += 1) {
+
+                //
+                // The same string configuration is made in two different
+                // buffers. RtlMoveMemory is used on the two strings in one
+                // buffer and the trusted LocalMoveMemory on the two strings
+                // in the other buffer. The entire buffers are compared to
+                // determine if the two move functions agree.
+                //
+
+                FillPattern(Buffer1, BUFFER_SIZE);
+                FillPattern(Buffer2, BUFFER_SIZE);
+
+                Source = MAX_MARGIN + MAX_LENGTH + MAX_MARGIN + Offset;
+                Target = Source + Overlap;
+
+                LocalMoveMemory(&Buffer1[Target], &Buffer1[Source], Length);
+                RtlMoveMemory(&Buffer2[Target], &Buffer2[Source], Length);
+
+                Result = LocalCompareMemory(Buffer1, Buffer2, BUFFER_SIZE);
+
+                TestCases += 1;
+                if (Result != BUFFER_SIZE) {
+                    ErrorCount += 1;
+
+                    printf("ERROR: Offset = %d, Length = %d, Overlap = %d\n",
+                           Offset, Length, Overlap);
+                    printf("RtlMoveMemory( &Buffer[ %d ], &Buffer[ %d ], %d )\n",
+                           Target, Source, Length);
+
+                    FillPattern(Buffer0, BUFFER_SIZE);
+                    printf("  Original Source = %lx: <%.*s>\n",
+                           &Buffer0[Source], Length, &Buffer0[Source]);
+                    printf("  Expected Target = %lx: <%.*s>\n",
+                           &Buffer1[Target], Length, &Buffer1[Target]);
+                    printf("  Actual Target   = %lx: <%.*s>\n",
+                           &Buffer2[Target], Length, &Buffer2[Target]);
+                    printf("\n");
+                    printf("Buffers differ starting at byte %d:\n", Result);
+                    printf("Buffer1 = <%*s>\n", BUFFER_SIZE, Buffer1);
+                    printf("Buffer2 = <%*s>\n", BUFFER_SIZE, Buffer2);
+                    printf("\n");
+                }
+            }
+        }
+    }
+
+    fprintf(stderr, "Test of RtlMoveMemory completed: ");
+    fprintf(stderr, "%d test cases, %d errors found.\n", TestCases, ErrorCount);
+}