Codebase list libjdom2-intellij-java / run/b9d2c674-17d4-4d84-a6ba-cb767d949ee7/main test / src / java / org / jdom / TestStringBin.java
run/b9d2c674-17d4-4d84-a6ba-cb767d949ee7/main

Tree @run/b9d2c674-17d4-4d84-a6ba-cb767d949ee7/main (Download .tar.gz)

TestStringBin.java @run/b9d2c674-17d4-4d84-a6ba-cb767d949ee7/main — raw · history · blame 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
package org.jdom;

import static org.junit.Assert.*;

import org.jdom.test.util.UnitTestUtil;
import org.junit.Test;

@SuppressWarnings("javadoc")
public class TestStringBin {
	
	// The following 4 all have the same hashcode 31776 ..... clever... huh?
	private static final String[] samehc = new String[] {
		"\u03FA\u00DA",
		"\u0401\u0001",
		"\u0400\u0020",
		"\u03FF\u003F",
		"   ",
		"\u03FE\u005E",
		"\u03FD\u007D",
		"\u03FC\u009C",
		"\u03FB\u00BB",
	};
	
	@Test
	public void testNegativeCapacity() {
		try {
			new StringBin(-1);
			fail("excpect exception!");
		} catch (Exception e) {
			UnitTestUtil.checkException(IllegalArgumentException.class, e);
		}
	}
	
	@Test
	public void testSmallCapacity() {
		assertNotNull(new StringBin(1));
	}
	
	@Test
	public void testNull() {
		StringBin bin = new StringBin();
		assertNull(bin.reuse(null));
	}
	
	@Test
	public void testSameHashCode() {
		for (int i = 0; i < samehc.length; i++) {
			int hc = samehc[i].hashCode();
			if (hc != 31776) {
				fail("Missed '" + samehc[i] + "' -> " + samehc[i].hashCode());
			}
		}
		StringBin bin = new StringBin();
		String[] actuals = new String[samehc.length];
		for (int i = 0; i < samehc.length; i++) {
			actuals[i] = bin.reuse(samehc[i]);
			assertEquals(samehc[i], actuals[i]);
			// should have compacted things.
			assertTrue(samehc[i] != actuals[i]);
		}
		assertTrue(bin.size() == samehc.length);
		for (int i = 0; i < samehc.length; i++) {
			assertTrue(actuals[i] == bin.reuse(samehc[i]));
		}
		assertTrue(bin.size() == samehc.length);
		
		
		bin = new StringBin();
		for (int i = samehc.length - 1; i >= 0; i--) {
			actuals[i] = bin.reuse(samehc[i]);
			assertEquals(samehc[i], actuals[i]);
			assertTrue(samehc[i] != actuals[i]);
		}
		for (int i = 0; i < samehc.length; i++) {
			assertTrue(actuals[i] == bin.reuse(samehc[i]));
		}
	}

	@Test
	public final void bulkIntern() {
		String[] tstvals = new String[1024 * 256];
		String[] actvals = new String[tstvals.length];
		String[] dupvals = new String[tstvals.length];
		StringBin bin = new StringBin(2048);
		int hc = 0;
		for (int i = 0; i < tstvals.length; i++) {
			tstvals[i] = "value " + i;
			hc ^= tstvals[i].hashCode();
			dupvals[i] = "value " + i;
			hc ^= dupvals[i].hashCode();
		}
		assertTrue(hc == 0);
		for (int i = 0; i < tstvals.length; i++) {
			actvals[i] = bin.reuse(tstvals[i]);
			assertTrue(tstvals[i] != actvals[i]);
			assertEquals(tstvals[i], actvals[i]);
		}
		assertTrue(bin.size() == tstvals.length);
		
		for (int i = 0; i < tstvals.length; i++) {
			assertTrue(actvals[i] == bin.reuse(tstvals[i]));
		}
		assertTrue(bin.size() == tstvals.length);
		
		for (int i = 0; i < tstvals.length; i++) {
			assertTrue(actvals[i] == bin.reuse(dupvals[i]));
		}
		assertTrue(bin.size() == tstvals.length);
		
		String[] acthc  = new String[samehc.length];
		for (int i = 0; i < samehc.length; i++) {
			acthc[i] = bin.reuse(samehc[i]);
			assertTrue(acthc[i] != samehc[i]);
			assertEquals(samehc[i], acthc[i]);
		}
		assertTrue(bin.size() == tstvals.length + samehc.length);
		for (int i = 0; i < samehc.length; i++) {
			assertTrue(acthc[i] == bin.reuse(samehc[i]));
		}
		assertTrue(bin.size() == tstvals.length + samehc.length);
	}
	
}