t.Fatalf("test %v: error: expected: %v, got: %v", i+1, testCase.expectErr, expectErr)
		}

		if !testCase.expectErr {
			if !reflect.DeepEqual(data, testCase.expectedData) {
				t.Fatalf("test %v: data: expected: %v, got: %v", i+1, string(testCase.expectedData), string(data))
			}
		}
	}
}

func TestNameUnmarshalXML(t *testing.T) {
	var blankName Name

	testCases := []struct {
		data         []byte

        assertEquals(testData.length, result);
        // Verify data was copied to outputBuffer
        byte[] expectedData = new byte[testData.length];
        System.arraycopy(outputBuffer, 0, expectedData, 0, testData.length);
        assertArrayEquals(testData, expectedData);
    }

    @Test
    void testReadDataWireFormatExceedsBuffer() {
        // Test when data length exceeds outputBuffer size

			t.Fatalf("test %v: error: expected: %v, got: %v", i+1, testCase.expectErr, expectErr)
		}

		if !testCase.expectErr {
			if !reflect.DeepEqual(data, testCase.expectedData) {
				t.Fatalf("test %v: data: expected: %v, got: %v", i+1, string(testCase.expectedData), string(data))
			}
		}
	}
}

func TestTargetDUnmarshalJSON(t *testing.T) {
	testCases := []struct {
		data             []byte
		expectedTargetID *TargetID

			t.Fatalf("test %v: error: expected: %v, got: %v", i+1, testCase.expectErr, expectErr)
		}

		if !testCase.expectErr {
			if !reflect.DeepEqual(data, testCase.expectedData) {
				t.Fatalf("test %v: data: expected: %v, got: %v", i+1, string(testCase.expectedData), string(data))
			}
		}
	}
}

func TestTargetDUnmarshalJSON(t *testing.T) {
	testCases := []struct {
		data             []byte
		expectedTargetID *TargetID

			t.Fatalf("test %v: error: expected: %v, got: %v", i+1, testCase.expectErr, expectErr)
		}

		if !testCase.expectErr {
			if !reflect.DeepEqual(data, testCase.expectedData) {
				t.Fatalf("test %v: data: expected: %v, got: %v", i+1, string(testCase.expectedData), string(data))
			}
		}
	}
}

func TestARNUnmarshalXML(t *testing.T) {
	testCases := []struct {
		data        []byte
		expectedARN *ARN
		expectErr   bool

		}
		// Set env var for test case 6
		if i+1 == 6 {
			scfg.Standard.Parity = 7
		}
		parity := scfg.GetParityForSC(tt.sc)
		if (tt.drivesCount - parity) != tt.expectedData {
			t.Errorf("Test %d, Expected data drives %d, got %d", i+1, tt.expectedData, tt.drivesCount-parity)
			continue
		}
		if parity != tt.expectedParity {
			t.Errorf("Test %d, Expected parity drives %d, got %d", i+1, tt.expectedParity, parity)
		}

   *     result doesn't match the expected value.
   */
  public void assertSuccess(Object expectedData) throws Throwable {
    // Verify that the listener executed in a reasonable amount of time.
    Assert.assertTrue(countDownLatch.await(1L, SECONDS));

    try {
      Assert.assertEquals(expectedData, future.get());
    } catch (ExecutionException e) {
      throw e.getCause();
    }
  }

  /**

        // Verify correct portion of data is copied
        byte[] expectedData = new byte[partialLength];
        System.arraycopy(TEST_DATA, partialOffset, expectedData, 0, partialLength);
        byte[] copiedData = new byte[partialLength];
        System.arraycopy(dst, dstIndex, copiedData, 0, partialLength);
        assertArrayEquals(expectedData, copiedData);
    }

    @Test