// of the read content as ETag. Optionally, it also computes
// the SHA256 checksum of the content.
//
// If the reference values for the ETag and content SHA26
// are not empty then it will check whether the computed
// match the reference values.
type Reader struct {
	src         io.Reader
	bytesRead   int64
	expectedMin int64
	expectedMax int64

	size       int64
	actualSize int64

	checksum      etag.ETag

            // When: Decoding into a new UUID
            rpc.uuid_t decodedUuid = new rpc.uuid_t();
            decodedUuid.decode(decodeBuffer);

            // Then: Values should match
            assertEquals(originalUuid.time_low, decodedUuid.time_low);
            assertEquals(originalUuid.time_mid, decodedUuid.time_mid);

		{rulesCase3, "2010/photos.jpg", NewTargetIDSet(TargetID{"1", "webhook"})},
		{rulesCase4, "2000/photos.jpg", NewTargetIDSet()},
	}

	for i, testCase := range testCases {
		result := testCase.rules.Match(testCase.objectName)

		if !reflect.DeepEqual(testCase.expectedResult, result) {
			t.Fatalf("test %v: result: expected: %v, got: %v", i+1, testCase.expectedResult, result)
		}
	}
}

      constructor = type.getConstructor();
    } catch (NoSuchMethodException e) {
      return arbitraryConstantInstanceOrNull(type);
    }
    constructor.setAccessible(true); // accessibility check is too slow
    try {
      return constructor.newInstance();
    } catch (InstantiationException | IllegalAccessException impossible) {
      throw new AssertionError(impossible);
    } catch (InvocationTargetException e) {

            String expected = canEncode ? String.valueOf(icon.getUnicodeChar()) : icon.getAsciiFallback();
            assertEquals(expected, result, "Icon should match charset encoding capability for " + icon);
        }
    }

    @Test
    @DisplayName("should be consistent across multiple calls")
    void shouldBeConsistentAcrossMultipleCalls() {

		{rulesMapCase4, ObjectCreatedPut, "2000/photo.png", NewTargetIDSet(TargetID{"2", "amqp"})},
	}

	for i, testCase := range testCases {
		result := testCase.rulesMap.Match(testCase.eventName, testCase.objectName)

		if !reflect.DeepEqual(result, testCase.expectedResult) {
			t.Fatalf("test %v: result: expected: %v, got: %v", i+1, testCase.expectedResult, result)
		}
	}
}

    void mapsKnownDosCodesToNtStatus(int dosCode, int expectedNtStatus) {
        // Act
        int actual = findNtStatusOrMinusOne(dosCode);

        // Assert
        assertEquals(expectedNtStatus, actual, "Mapping must match table entry");
    }

    @Test
    @DisplayName("Edge: zero DOS code maps to zero NTSTATUS")
    void zeroCodeMapsToZero() {
        // Act
        int actual = findNtStatusOrMinusOne(0x00000000);

				t.Errorf("Test %d: failed to write data blocks: %v", i, err)
			}
			if !bytes.Equal(decodedData.Bytes(), data) {
				t.Errorf("Test %d: Decoded data does not match original data: got: %v want: %v", i, decodedData.Bytes(), data)
			}
		}
	}
}

// Setup for erasureCreateFile and erasureReadFile tests.
type erasureTestSetup struct {
	dataBlocks   int

                        verifyChecksum(sha1ChecksumObserver, destination, temp, remotePath, ".sha1", wagon);
                    } catch (ChecksumFailedException e) {
                        // if we catch a ChecksumFailedException, it means the transfer/read succeeded, but the
                        // checksum doesn't match. This could be a problem with the server (ibiblio HTTP-200 error

        List<WitnessNotification> batch = new ArrayList<>();
        
        synchronized (pendingNotifications) {
            while (!pendingNotifications.isEmpty() && batch.size() < batchSize) {
                batch.add(pendingNotifications.poll());
            }
        }
        
        if (!batch.isEmpty()) {
            processNotificationBatch(batch);
        }
    }