ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/ConcurrentHashMap8Test.java

Comparing jsr166/src/test/tck/ConcurrentHashMap8Test.java (file contents):
Revision 1.4 by jsr166, Fri Mar 22 16:10:19 2013 UTC vs.
Revision 1.8 by jsr166, Thu Apr 11 20:03:44 2013 UTC

#	Line 699 | Line 699 | public class ConcurrentHashMap8Test exte
699		assertEquals(r.getKey().longValue(), (long)SIZE * (SIZE - 1) / 2);
700		}
701
702	<	/*
702	>	/**
703		* Mapped reduceKeysSequentially accumulates mapped keys
704		*/
705		public void testMapReduceKeysSequentially() {
#	Line 709 | Line 709 | public class ConcurrentHashMap8Test exte
709		assertEquals((long)r, (long)4 * SIZE * (SIZE - 1) / 2);
710		}
711
712	<	/*
712	>	/**
713		* Mapped reduceValuesSequentially accumulates mapped values
714		*/
715		public void testMapReduceValuesSequentially() {
#	Line 730 | Line 730 | public class ConcurrentHashMap8Test exte
730		assertEquals((long)r, (long)3 * SIZE * (SIZE - 1) / 2);
731		}
732
733	<	/*
733	>	/**
734		* Mapped reduceKeysInParallel, accumulates mapped keys
735		*/
736		public void testMapReduceKeysInParallel() {
#	Line 740 | Line 740 | public class ConcurrentHashMap8Test exte
740		assertEquals((long)r, (long)4 * SIZE * (SIZE - 1) / 2);
741		}
742
743	<	/*
743	>	/**
744		* Mapped reduceValuesInParallel accumulates mapped values
745		*/
746		public void testMapReduceValuesInParallel() {
#	Line 762 | Line 762 | public class ConcurrentHashMap8Test exte
762		}
763
764
765	<	/*
765	>	/**
766		* reduceKeysToLongSequentially accumulates mapped keys
767		*/
768		public void testReduceKeysToLongSequentially() {
#	Line 771 | Line 771 | public class ConcurrentHashMap8Test exte
771		assertEquals(lr, (long)SIZE * (SIZE - 1) / 2);
772		}
773
774	<	/*
774	>	/**
775		* reduceKeysToIntSequentially accumulates mapped keys
776		*/
777		public void testReduceKeysToIntSequentially() {
778		ConcurrentHashMap<Long, Long> m = longMap();
779		int ir = m.reduceKeysToIntSequentially((Long x) -> x.intValue(), 0, Integer::sum);
780	<	assertEquals(ir, (int)SIZE * (SIZE - 1) / 2);
780	>	assertEquals(ir, SIZE * (SIZE - 1) / 2);
781		}
782
783	<	/*
783	>	/**
784		* reduceKeysToDoubleSequentially accumulates mapped keys
785		*/
786		public void testReduceKeysToDoubleSequentially() {
#	Line 789 | Line 789 | public class ConcurrentHashMap8Test exte
789		assertEquals(dr, (double)SIZE * (SIZE - 1) / 2);
790		}
791
792	<	/*
792	>	/**
793		* reduceValuesToLongSequentially accumulates mapped values
794		*/
795		public void testReduceValuesToLongSequentially() {
#	Line 798 | Line 798 | public class ConcurrentHashMap8Test exte
798		assertEquals(lr, (long)SIZE * (SIZE - 1));
799		}
800
801	<	/*
801	>	/**
802		* reduceValuesToIntSequentially accumulates mapped values
803		*/
804		public void testReduceValuesToIntSequentially() {
805		ConcurrentHashMap<Long, Long> m = longMap();
806		int ir = m.reduceValuesToIntSequentially((Long x) -> x.intValue(), 0, Integer::sum);
807	<	assertEquals(ir, (int)SIZE * (SIZE - 1));
807	>	assertEquals(ir, SIZE * (SIZE - 1));
808		}
809
810	<	/*
810	>	/**
811		* reduceValuesToDoubleSequentially accumulates mapped values
812		*/
813		public void testReduceValuesToDoubleSequentially() {
#	Line 816 | Line 816 | public class ConcurrentHashMap8Test exte
816		assertEquals(dr, (double)SIZE * (SIZE - 1));
817		}
818
819	<	/*
819	>	/**
820		* reduceKeysToLongInParallel accumulates mapped keys
821		*/
822		public void testReduceKeysToLongInParallel() {
#	Line 825 | Line 825 | public class ConcurrentHashMap8Test exte
825		assertEquals(lr, (long)SIZE * (SIZE - 1) / 2);
826		}
827
828	<	/*
828	>	/**
829		* reduceKeysToIntInParallel accumulates mapped keys
830		*/
831		public void testReduceKeysToIntInParallel() {
832		ConcurrentHashMap<Long, Long> m = longMap();
833		int ir = m.reduceKeysToIntInParallel((Long x) -> x.intValue(), 0, Integer::sum);
834	<	assertEquals(ir, (int)SIZE * (SIZE - 1) / 2);
834	>	assertEquals(ir, SIZE * (SIZE - 1) / 2);
835		}
836
837	<	/*
837	>	/**
838		* reduceKeysToDoubleInParallel accumulates mapped values
839		*/
840		public void testReduceKeysToDoubleInParallel() {
#	Line 843 | Line 843 | public class ConcurrentHashMap8Test exte
843		assertEquals(dr, (double)SIZE * (SIZE - 1) / 2);
844		}
845
846	<	/*
846	>	/**
847		* reduceValuesToLongInParallel accumulates mapped values
848		*/
849		public void testReduceValuesToLongInParallel() {
#	Line 852 | Line 852 | public class ConcurrentHashMap8Test exte
852		assertEquals(lr, (long)SIZE * (SIZE - 1));
853		}
854
855	<	/*
855	>	/**
856		* reduceValuesToIntInParallel accumulates mapped values
857		*/
858		public void testReduceValuesToIntInParallel() {
859		ConcurrentHashMap<Long, Long> m = longMap();
860		int ir = m.reduceValuesToIntInParallel((Long x) -> x.intValue(), 0, Integer::sum);
861	<	assertEquals(ir, (int)SIZE * (SIZE - 1));
861	>	assertEquals(ir, SIZE * (SIZE - 1));
862		}
863
864	<	/*
864	>	/**
865		* reduceValuesToDoubleInParallel accumulates mapped values
866		*/
867		public void testReduceValuesToDoubleInParallel() {
#	Line 1043 | Line 1043 | public class ConcurrentHashMap8Test exte
1043		assertEquals(lr, (long)SIZE * (SIZE - 1) / 2);
1044		ir = ConcurrentHashMap.ForkJoinTasks.reduceKeysToInt
1045		(m, (Long x) -> x.intValue(), 0, Integer::sum).invoke();
1046	<	assertEquals(ir, (int)SIZE * (SIZE - 1) / 2);
1046	>	assertEquals(ir, SIZE * (SIZE - 1) / 2);
1047		dr = ConcurrentHashMap.ForkJoinTasks.reduceKeysToDouble
1048		(m, (Long x) -> x.doubleValue(), 0.0, Double::sum).invoke();
1049		assertEquals(dr, (double)SIZE * (SIZE - 1) / 2);
#	Line 1056 | Line 1056 | public class ConcurrentHashMap8Test exte
1056		assertEquals(lr, (long)SIZE * (SIZE - 1));
1057		ir = ConcurrentHashMap.ForkJoinTasks.reduceValuesToInt
1058		(m, (Long x) -> x.intValue(), 0, Integer::sum).invoke();
1059	<	assertEquals(ir, (int)SIZE * (SIZE - 1));
1059	>	assertEquals(ir, SIZE * (SIZE - 1));
1060		dr = ConcurrentHashMap.ForkJoinTasks.reduceValuesToDouble
1061		(m, (Long x) -> x.doubleValue(), 0.0, Double::sum).invoke();
1062		assertEquals(dr, (double)SIZE * (SIZE - 1));

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines