varianttest.java

java与windows的com桥,可以用来操作所有的com程序如word或者excel等

			v.getString();
			fail("IllegalStateException should have been thrown when querying safeReleased object");
			throw new RuntimeException("test failed");
		} catch (IllegalStateException ise) {
			// System.out.println("IllegalStateException correctly thrown after
			// safeRelease");
		}
	}

	/**
	 * verifies objectIsAConstant works as expected
	 * 
	 */
	public void testObjectIsAConstant() {
		Variant v = new Variant("d");
		if (!v.objectIsAConstant(Variant.VT_FALSE)) {
			fail("did not recognize VT_FALSE");
		}
		if (!v.objectIsAConstant(Variant.VT_TRUE)) {
			fail("did not recognize VT_TRUE");
		}
		if (!v.objectIsAConstant(Variant.VT_MISSING)) {
			fail("did not recognize VT_MISSING");
		}
		if (!v.objectIsAConstant(Variant.DEFAULT)) {
			fail("did not recognize DEFAULT");
		}
		if (v.objectIsAConstant(new Variant(true))) {
			fail("confused a boolean with VT_TRUE");
		}
		if (v.objectIsAConstant(new Variant(false))) {
			fail("confused a boolean with VT_FALSE");
		}

	}

	/**
	 * tests put and get methods looking for obvious defects
	 * 
	 */
	public void testPutsAndGets() {
		Variant v = new Variant();

		v.putInt(10);
		assertEquals("int test failed", 10, v.getInt());

		v.putShort((short) 20);
		assertEquals("short test failed", (short) 20, v.getShort());

		v.putByte((byte) 30);
		assertEquals("byte test failed", (byte) 30, v.getByte());

		v.putFloat(40);
		if (v.getFloat() != 40.0) {
			fail("float test failed");
		}

		v.putDouble(50);
		if (v.getDouble() != 50.0) {
			fail("double test failed");
		}

		v.putString("1234.567");
		assertEquals("string test failed", "1234.567", v.getString());

		v.putBoolean(true);
		assertEquals("failed boolean test(true)", true, v.getBoolean());

		v.putBoolean(false);
		assertEquals("failed boolean test(false)", false, v.getBoolean());

		long originalValue = 123456789123456789L;
		v.putCurrency(new Currency(originalValue));
		assertEquals("failed currency test", 123456789123456789L, v
				.getCurrency().longValue());

		BigDecimal testDecimal = new BigDecimal("22.222");
		v.putDecimal(testDecimal);
		assertEquals("failed BigDecimal test", testDecimal, v.getDecimal());

		Date ourDate = new Date();
		v.putDate(ourDate);
		Date retrievedDate = v.getJavaDate();
		if (!retrievedDate.equals(ourDate)) {
			fail("failed java date load and unload");
		}

		v.putNull();
		if (!v.isNull()) {
			fail("failed detecting set null");
		}
		v.putString("something other than null");
		if (v.isNull()) {
			fail("failed null replacement with string");
		}

		v.putEmpty();
		if (!v.isNull()) {
			fail("failed detecting set empty as null");
		}
		v.putString("something other than null");
		if (v.isNull()) {
			fail("failed empty replacement with string as isNull");
		}

		Variant v2 = new Variant();
		v2.putNothing();
		if (v2.getvt() != Variant.VariantDispatch) {
			fail("putNothing was supposed to set the type to VariantDispatch");
		}
		if (!v2.isNull()) {
			fail("putNothing is supposed to cause isNull() to return true");
		}
		// this line blows up in the test above
		if (v2.toJavaObject() == null) {
			fail("putNothing() followed by toJavaObject() should return a Dispatch");
		}

	}

	/**
	 * verify decimal works right
	 */
	public void testDecimalConversion() {
		Variant v = new Variant();
		v.changeType(Variant.VariantDecimal);
		for (int i = 10; i >= -10; i--) {
			v.putDecimal(new BigDecimal(i));
			// first see if we can get it back as decimal
			assertEquals("conversion back to decimal failed " + i,
					new BigDecimal(i), v.getDecimal());
			v.changeType(Variant.VariantFloat);
			// now see if a float conversion would work
			assertEquals("conversion to float failed " + i, new Float(i), v
					.getFloat());
			// now convert it back to decimal for reassignment
			v.changeType(Variant.VariantDecimal);
			assertTrue("Failed conversion of type back to Decimal " + i, v
					.getvt() == Variant.VariantDecimal);
		}

	}

	/**
	 * for(BigDecimal i in 79228162514264337593543950330.0 ..
	 * 79228162514264337593543950341.0) { com.jacob.com.Variant dv = new
	 * com.jacob.com.Variant(i, false) println i + " : " + dv.getDecimal() }
	 * 
	 */
	public void testLargeDecimals() {
		// the largest decimal number, not in hex is
		// 7922816251426433759354395033.0
		BigInteger theStartDigits = new BigInteger("ffffffffffffffffffffff00",
				16);
		BigInteger theMaxDigits = new BigInteger("ffffffffffffffffffffffff", 16);
		BigDecimal startDecimal = new BigDecimal(theStartDigits);
		BigDecimal endDecimal = new BigDecimal(theMaxDigits);
		BigDecimal incrementDecimal = new BigDecimal(1);
		BigDecimal testDecimal = startDecimal;
		Variant testVariant;
		while (endDecimal.compareTo(testDecimal) >= 0) {
			testVariant = new Variant(testDecimal, false);
			BigDecimal result = testVariant.getDecimal();
			assertEquals(testDecimal, result);
			testDecimal = testDecimal.add(incrementDecimal);
		}
		// test Decimal is now too large
		try {
			new Variant(testDecimal, false);
		} catch (IllegalArgumentException iae) {
			// System.out.println("Caught expected exception");
		}
		// lets try something different. we can call putVariant with rounding
		// enabled
		testVariant = new Variant();
		testVariant.changeType(Variant.VariantDecimal);
		try {
			testVariant.putDecimal(endDecimal.setScale(30));
			fail("Should have thrown exception with scale of 30 and no rounding");
		} catch (IllegalArgumentException iae) {
			// should have caught this exception
		}
		// now we test with a negative scale. Note that you can't do with
		// without some magic, in this case scientific notation
		try {
			testVariant.putDecimal(new BigDecimal("700E24"));
			assertTrue(new BigDecimal("700E24").compareTo(testVariant
					.getDecimal()) == 0);
		} catch (IllegalArgumentException iae) {
			// should have caught this exception
		}

		testVariant.putDecimal(VariantUtilities
				.roundToMSDecimal(new BigDecimal("700E24")));
		// use compareTo because it takes into account varying scales
		assertTrue(new BigDecimal("700E24").compareTo(testVariant.getDecimal()) == 0);

		// This passes because the number is within range.
		testVariant.putDecimal(endDecimal);

		// this should pass because we have rounding turned on
		// it turns out the max number gets more digits when
		// it's scale is set to 30. so we can't use the max number when there is
		// a scale
		BigDecimal modifiedDecimal = endDecimal;
		System.out.println("integer piece starts                       as "
				+ modifiedDecimal.unscaledValue().toString(16) + " scale=: "
				+ modifiedDecimal.scale());
		System.out.println("integer piece after rounding without scale is "
				+ VariantUtilities.roundToMSDecimal(modifiedDecimal)
						.unscaledValue().toString(16) + " scale=: "
				+ modifiedDecimal.scale());
		System.out.println("integer piece after rounding with scale 30 is "
				+ VariantUtilities.roundToMSDecimal(
						modifiedDecimal.setScale(30)).unscaledValue().toString(
						16) + " scale=: " + modifiedDecimal.scale());
		try {
			testVariant.putDecimal(VariantUtilities
					.roundToMSDecimal(modifiedDecimal.setScale(30)));
			fail("should have thrown an exception for a number whose scale "
					+ "change created too many digits to be represented.");
		} catch (IllegalArgumentException iae) {
			// should catch an exception here because the rounding after scale
			// change would have made the number too large
		}

		System.out.println("");
		modifiedDecimal = endDecimal.subtract(incrementDecimal);
		System.out.println("integer piece starts                       as "
				+ modifiedDecimal.unscaledValue().toString(16) + " scale=: "
				+ modifiedDecimal.scale());
		System.out.println("integer piece after rounding without scale is "
				+ VariantUtilities.roundToMSDecimal(modifiedDecimal)
						.unscaledValue().toString(16) + " scale=: "
				+ modifiedDecimal.scale());
		System.out.println("integer piece after rounding with scale 30 is "
				+ VariantUtilities.roundToMSDecimal(
						modifiedDecimal.setScale(30)).unscaledValue().toString(
						16) + " scale=: " + modifiedDecimal.scale());
		testVariant.putDecimal(VariantUtilities
				.roundToMSDecimal(modifiedDecimal.setScale(30)));
		System.out.println("");
	}

	/**
	 * Spin up a lot of threads and have them all create variants 3/2007 there
	 * have been several reports in multi-threaded servers that show init()
	 * failing
	 * 
	 */
	public void testManyThreadedInit() {
		VariantInitTestThread threads[] = new VariantInitTestThread[75];

		System.out.println("Starting thread test (" + threads.length
				+ " threads each creating 10000 objects)."
				+ " This may take 30 seconds or more.");
		for (int i = 0; i < threads.length; i++) {
			threads[i] = new VariantInitTestThread("thread-" + i, 10000);
		}
		for (int i = 0; i < threads.length; i++) {
			threads[i].start();
		}
		int numComplete = 0;
		while (numComplete < threads.length) {
			// give the works time to work
			try {
				Thread.sleep(333);
			} catch (InterruptedException ie) {
				// do nothing
			}
			numComplete = 0;
			for (int i = 0; i < threads.length; i++) {
				if (threads[i].isComplete) {
					numComplete++;
				}
			}
			// System.out.print("["+numComplete+"/"+threads.length+"]");
		}
		System.out.println("Finished thread test");
	}

	/**
	 * a class to create variants in separate threads
	 * 
	 */
	class VariantInitTestThread extends Thread {
		private boolean isComplete = false;

		private int initialRunSize = 0;

		/**
		 * @param newThreadName
		 *            the name for the thread
		 * @param iStartCount
		 *            number of threads to start with
		 */
		public VariantInitTestThread(String newThreadName, int iStartCount) {
			super(newThreadName);
			initialRunSize = iStartCount;

		}

		/**
		 * getter so master can see if thread is done
		 * 
		 * @return state of complete flag
		 */
		public boolean isComplete() {
			return isComplete;
		}

		/**
		 * Blow out a bunch of Variants
		 * 
		 * @see java.lang.Runnable#run()
		 */
		public void run() {
			for (int variantIndex = 0; variantIndex < initialRunSize; variantIndex++) {
				try {
					Thread.yield();
					Thread.sleep(0);
				} catch (InterruptedException ie) {
					// do nothing
				}
				// System.out.println(Thread.currentThread().getName());
				Variant testSubject = new Variant(variantIndex);
				testSubject.getvt();
				testSubject.getInt();
			}
			isComplete = true;
		}
	}
}