@@ -873,230 +873,11 @@ impl<'a, K: Hash + Eq, V, S: HashState> IntoIterator for &'a mut LinkedHashMap<K
873
873
}
874
874
875
875
#[ cfg( test) ]
876
- mod tests {
877
- use super :: LinkedHashMap ;
878
-
879
- fn assert_opt_eq < V : PartialEq > ( opt : Option < & V > , v : V ) {
880
- assert ! ( opt. is_some( ) ) ;
881
- assert ! ( opt. unwrap( ) == & v) ;
882
- }
883
-
884
- #[ test]
885
- fn test_insert_and_get ( ) {
886
- let mut map = LinkedHashMap :: new ( ) ;
887
- map. insert ( 1 , 10 ) ;
888
- map. insert ( 2 , 20 ) ;
889
- assert_opt_eq ( map. get ( & 1 ) , 10 ) ;
890
- assert_opt_eq ( map. get ( & 2 ) , 20 ) ;
891
- assert_eq ! ( map. len( ) , 2 ) ;
892
- }
893
-
894
- #[ test]
895
- fn test_index ( ) {
896
- let mut map = LinkedHashMap :: new ( ) ;
897
- map. insert ( 1 , 10 ) ;
898
- map. insert ( 2 , 20 ) ;
899
- assert_eq ! ( 10 , map[ & 1 ] ) ;
900
- map[ & 2 ] = 22 ;
901
- assert_eq ! ( 22 , map[ & 2 ] ) ;
902
- }
903
-
904
- #[ test]
905
- fn test_insert_update ( ) {
906
- let mut map = LinkedHashMap :: new ( ) ;
907
- map. insert ( "1" . to_string ( ) , vec ! [ 10 , 10 ] ) ;
908
- map. insert ( "1" . to_string ( ) , vec ! [ 10 , 19 ] ) ;
909
- assert_opt_eq ( map. get ( & "1" . to_string ( ) ) , vec ! [ 10 , 19 ] ) ;
910
- assert_eq ! ( map. len( ) , 1 ) ;
911
- }
912
-
913
- #[ test]
914
- fn test_debug ( ) {
915
- let mut map = LinkedHashMap :: new ( ) ;
916
- assert_eq ! ( format!( "{:?}" , map) , "{}" ) ;
917
- map. insert ( 1 , 10 ) ;
918
- map. insert ( 2 , 20 ) ;
919
- map. insert ( 3 , 30 ) ;
920
- assert_eq ! ( format!( "{:?}" , map) , "{1: 10, 2: 20, 3: 30}" ) ;
921
- map. insert ( 2 , 22 ) ;
922
- assert_eq ! ( format!( "{:?}" , map) , "{1: 10, 3: 30, 2: 22}" ) ;
923
- map. get ( & 3 ) ;
924
- assert_eq ! ( format!( "{:?}" , map) , "{1: 10, 3: 30, 2: 22}" ) ;
925
- map. get_refresh ( & mut 3 ) ;
926
- assert_eq ! ( format!( "{:?}" , map) , "{1: 10, 2: 22, 3: 30}" ) ;
927
- map. clear ( ) ;
928
- assert_eq ! ( format!( "{:?}" , map) , "{}" ) ;
929
- }
930
-
931
- #[ test]
932
- fn test_remove ( ) {
933
- let mut map = LinkedHashMap :: new ( ) ;
934
- map. insert ( 1 , 10 ) ;
935
- map. insert ( 2 , 20 ) ;
936
- map. insert ( 3 , 30 ) ;
937
- map. insert ( 4 , 40 ) ;
938
- map. insert ( 5 , 50 ) ;
939
- map. remove ( & 3 ) ;
940
- map. remove ( & 4 ) ;
941
- assert ! ( map. get( & 3 ) . is_none( ) ) ;
942
- assert ! ( map. get( & 4 ) . is_none( ) ) ;
943
- map. insert ( 6 , 60 ) ;
944
- map. insert ( 7 , 70 ) ;
945
- map. insert ( 8 , 80 ) ;
946
- assert_opt_eq ( map. get ( & 6 ) , 60 ) ;
947
- assert_opt_eq ( map. get ( & 7 ) , 70 ) ;
948
- assert_opt_eq ( map. get ( & 8 ) , 80 ) ;
949
- }
950
-
951
-
952
- #[ test]
953
- fn test_pop ( ) {
954
- let mut map = LinkedHashMap :: new ( ) ;
955
- map. insert ( 1 , 10 ) ;
956
- map. insert ( 2 , 20 ) ;
957
- map. insert ( 3 , 30 ) ;
958
- map. insert ( 4 , 40 ) ;
959
- map. insert ( 5 , 50 ) ;
960
- assert_eq ! ( map. pop_front( ) , Some ( ( 1 , 10 ) ) ) ;
961
- assert ! ( map. get( & 1 ) . is_none( ) ) ;
962
- assert_eq ! ( map. pop_back( ) , Some ( ( 5 , 50 ) ) ) ;
963
- assert ! ( map. get( & 5 ) . is_none( ) ) ;
964
- map. insert ( 6 , 60 ) ;
965
- map. insert ( 7 , 70 ) ;
966
- map. insert ( 8 , 80 ) ;
967
- assert_eq ! ( map. pop_front( ) , Some ( ( 2 , 20 ) ) ) ;
968
- assert ! ( map. get( & 2 ) . is_none( ) ) ;
969
- assert_eq ! ( map. pop_back( ) , Some ( ( 8 , 80 ) ) ) ;
970
- assert ! ( map. get( & 8 ) . is_none( ) ) ;
971
- map. insert ( 3 , 30 ) ;
972
- assert_eq ! ( map. pop_front( ) , Some ( ( 4 , 40 ) ) ) ;
973
- assert ! ( map. get( & 4 ) . is_none( ) ) ;
974
- assert_eq ! ( map. pop_back( ) , Some ( ( 3 , 30 ) ) ) ;
975
- assert ! ( map. get( & 3 ) . is_none( ) ) ;
976
- }
977
-
978
- #[ test]
979
- fn test_clear ( ) {
980
- let mut map = LinkedHashMap :: new ( ) ;
981
- map. insert ( 1 , 10 ) ;
982
- map. insert ( 2 , 20 ) ;
983
- map. clear ( ) ;
984
- assert ! ( map. get( & 1 ) . is_none( ) ) ;
985
- assert ! ( map. get( & 2 ) . is_none( ) ) ;
986
- assert_eq ! ( format!( "{:?}" , map) , "{}" ) ;
987
- }
988
-
989
- #[ test]
990
- fn test_iter ( ) {
991
- let mut map = LinkedHashMap :: new ( ) ;
992
-
993
- // empty iter
994
- assert_eq ! ( None , map. iter( ) . next( ) ) ;
995
-
996
- map. insert ( "a" , 10 ) ;
997
- map. insert ( "b" , 20 ) ;
998
- map. insert ( "c" , 30 ) ;
999
-
1000
- // regular iter
1001
- let mut iter = map. iter ( ) ;
1002
- assert_eq ! ( ( & "a" , & 10 ) , iter. next( ) . unwrap( ) ) ;
1003
- assert_eq ! ( ( & "b" , & 20 ) , iter. next( ) . unwrap( ) ) ;
1004
- assert_eq ! ( ( & "c" , & 30 ) , iter. next( ) . unwrap( ) ) ;
1005
- assert_eq ! ( None , iter. next( ) ) ;
1006
- assert_eq ! ( None , iter. next( ) ) ;
1007
-
1008
- // reversed iter
1009
- let mut rev_iter = map. iter ( ) . rev ( ) ;
1010
- assert_eq ! ( ( & "c" , & 30 ) , rev_iter. next( ) . unwrap( ) ) ;
1011
- assert_eq ! ( ( & "b" , & 20 ) , rev_iter. next( ) . unwrap( ) ) ;
1012
- assert_eq ! ( ( & "a" , & 10 ) , rev_iter. next( ) . unwrap( ) ) ;
1013
- assert_eq ! ( None , rev_iter. next( ) ) ;
1014
- assert_eq ! ( None , rev_iter. next( ) ) ;
1015
-
1016
- // mixed
1017
- let mut mixed_iter = map. iter ( ) ;
1018
- assert_eq ! ( ( & "a" , & 10 ) , mixed_iter. next( ) . unwrap( ) ) ;
1019
- assert_eq ! ( ( & "c" , & 30 ) , mixed_iter. next_back( ) . unwrap( ) ) ;
1020
- assert_eq ! ( ( & "b" , & 20 ) , mixed_iter. next( ) . unwrap( ) ) ;
1021
- assert_eq ! ( None , mixed_iter. next( ) ) ;
1022
- assert_eq ! ( None , mixed_iter. next_back( ) ) ;
1023
- }
1024
-
1025
- #[ test]
1026
- fn test_iter_mut ( ) {
1027
- let mut map = LinkedHashMap :: new ( ) ;
1028
- map. insert ( "a" , 10 ) ;
1029
- map. insert ( "c" , 30 ) ;
1030
- map. insert ( "b" , 20 ) ;
1031
-
1032
- {
1033
- let mut iter = map. iter_mut ( ) ;
1034
- let entry = iter. next ( ) . unwrap ( ) ;
1035
- assert_eq ! ( & "a" , entry. 0 ) ;
1036
- * entry. 1 = 17 ;
1037
-
1038
- // reverse iterator
1039
- let mut iter = iter. rev ( ) ;
1040
- let entry = iter. next ( ) . unwrap ( ) ;
1041
- assert_eq ! ( & "b" , entry. 0 ) ;
1042
- * entry. 1 = 23 ;
1043
-
1044
- let entry = iter. next ( ) . unwrap ( ) ;
1045
- assert_eq ! ( & "c" , entry. 0 ) ;
1046
- assert_eq ! ( None , iter. next( ) ) ;
1047
- assert_eq ! ( None , iter. next( ) ) ;
1048
- }
1049
-
1050
- assert_eq ! ( 17 , map[ & "a" ] ) ;
1051
- assert_eq ! ( 23 , map[ & "b" ] ) ;
1052
- }
1053
-
1054
- #[ test]
1055
- fn test_borrow ( ) {
1056
- #[ derive( PartialEq , Eq , Hash ) ] struct Foo ( Bar ) ;
1057
- #[ derive( PartialEq , Eq , Hash ) ] struct Bar ( i32 ) ;
1058
-
1059
- impl :: std:: borrow:: Borrow < Bar > for Foo {
1060
- fn borrow ( & self ) -> & Bar { & self . 0 }
1061
- }
1062
-
1063
- let mut map = LinkedHashMap :: new ( ) ;
1064
- map. insert ( Foo ( Bar ( 1 ) ) , "a" ) ;
1065
- map. insert ( Foo ( Bar ( 2 ) ) , "b" ) ;
1066
-
1067
- assert ! ( map. contains_key( & Bar ( 1 ) ) ) ;
1068
- assert ! ( map. contains_key( & Bar ( 2 ) ) ) ;
1069
- assert ! ( map. contains_key( & Foo ( Bar ( 1 ) ) ) ) ;
1070
- assert ! ( map. contains_key( & Foo ( Bar ( 2 ) ) ) ) ;
1071
-
1072
- assert_eq ! ( map. get( & Bar ( 1 ) ) , Some ( & "a" ) ) ;
1073
- assert_eq ! ( map. get( & Bar ( 2 ) ) , Some ( & "b" ) ) ;
1074
- assert_eq ! ( map. get( & Foo ( Bar ( 1 ) ) ) , Some ( & "a" ) ) ;
1075
- assert_eq ! ( map. get( & Foo ( Bar ( 2 ) ) ) , Some ( & "b" ) ) ;
1076
-
1077
- assert_eq ! ( map. get_refresh( & Bar ( 1 ) ) , Some ( & mut "a" ) ) ;
1078
- assert_eq ! ( map. get_refresh( & Bar ( 2 ) ) , Some ( & mut "b" ) ) ;
1079
- assert_eq ! ( map. get_refresh( & Foo ( Bar ( 1 ) ) ) , Some ( & mut "a" ) ) ;
1080
- assert_eq ! ( map. get_refresh( & Foo ( Bar ( 2 ) ) ) , Some ( & mut "b" ) ) ;
1081
-
1082
- assert_eq ! ( map. get_mut( & Bar ( 1 ) ) , Some ( & mut "a" ) ) ;
1083
- assert_eq ! ( map. get_mut( & Bar ( 2 ) ) , Some ( & mut "b" ) ) ;
1084
- assert_eq ! ( map. get_mut( & Foo ( Bar ( 1 ) ) ) , Some ( & mut "a" ) ) ;
1085
- assert_eq ! ( map. get_mut( & Foo ( Bar ( 2 ) ) ) , Some ( & mut "b" ) ) ;
1086
-
1087
- assert_eq ! ( map[ & Bar ( 1 ) ] , "a" ) ;
1088
- assert_eq ! ( map[ & Bar ( 2 ) ] , "b" ) ;
1089
- assert_eq ! ( map[ & Foo ( Bar ( 1 ) ) ] , "a" ) ;
1090
- assert_eq ! ( map[ & Foo ( Bar ( 2 ) ) ] , "b" ) ;
1091
-
1092
- assert_eq ! ( map. remove( & Bar ( 1 ) ) , Some ( "a" ) ) ;
1093
- assert_eq ! ( map. remove( & Bar ( 2 ) ) , Some ( "b" ) ) ;
1094
- assert_eq ! ( map. remove( & Foo ( Bar ( 1 ) ) ) , None ) ;
1095
- assert_eq ! ( map. remove( & Foo ( Bar ( 2 ) ) ) , None ) ;
1096
- }
1097
-
876
+ mod bench {
1098
877
extern crate test;
1099
878
879
+ use super :: LinkedHashMap ;
880
+
1100
881
#[ bench]
1101
882
fn not_recycled_cycling ( b : & mut test:: Bencher ) {
1102
883
let mut hash_map = LinkedHashMap :: with_capacity ( 1000 ) ;
0 commit comments