@@ -850,6 +850,16 @@ mod tests {
850
850
assert_eq ! ( a. as_slice( ) . head( ) . unwrap( ) , & 11 ) ;
851
851
}
852
852
853
+ #[ test]
854
+ fn test_head_mut ( ) {
855
+ let mut a = vec ! [ ] ;
856
+ assert_eq ! ( a. as_mut_slice( ) . head_mut( ) , None ) ;
857
+ a = vec ! [ 11 i] ;
858
+ assert_eq ! ( * a. as_mut_slice( ) . head_mut( ) . unwrap( ) , 11 ) ;
859
+ a = vec ! [ 11 i, 12 ] ;
860
+ assert_eq ! ( * a. as_mut_slice( ) . head_mut( ) . unwrap( ) , 11 ) ;
861
+ }
862
+
853
863
#[ test]
854
864
fn test_tail ( ) {
855
865
let mut a = vec ! [ 11 i] ;
@@ -860,22 +870,39 @@ mod tests {
860
870
assert_eq ! ( a. tail( ) , b) ;
861
871
}
862
872
873
+ #[ test]
874
+ fn test_tail_mut ( ) {
875
+ let mut a = vec ! [ 11 i] ;
876
+ let b: & mut [ int ] = & mut [ ] ;
877
+ assert ! ( a. as_mut_slice( ) . tail_mut( ) == b) ;
878
+ a = vec ! [ 11 i, 12 ] ;
879
+ let b: & mut [ int ] = & mut [ 12 ] ;
880
+ assert ! ( a. as_mut_slice( ) . tail_mut( ) == b) ;
881
+ }
882
+
863
883
#[ test]
864
884
#[ should_fail]
865
885
fn test_tail_empty ( ) {
866
886
let a: Vec < int > = vec ! [ ] ;
867
887
a. tail ( ) ;
868
888
}
869
889
890
+ #[ test]
891
+ #[ should_fail]
892
+ fn test_tail_mut_empty ( ) {
893
+ let mut a: Vec < int > = vec ! [ ] ;
894
+ a. as_mut_slice ( ) . tail_mut ( ) ;
895
+ }
896
+
870
897
#[ test]
871
898
#[ allow( deprecated) ]
872
899
fn test_tailn ( ) {
873
900
let mut a = vec ! [ 11 i, 12 , 13 ] ;
874
- let b: & [ int ] = & [ 11 , 12 , 13 ] ;
875
- assert_eq ! ( a. tailn( 0 ) , b) ;
901
+ let b: & mut [ int ] = & mut [ 11 , 12 , 13 ] ;
902
+ assert ! ( a. tailn( 0 ) == b) ;
876
903
a = vec ! [ 11 i, 12 , 13 ] ;
877
- let b: & [ int ] = & [ 13 ] ;
878
- assert_eq ! ( a. tailn( 2 ) , b) ;
904
+ let b: & mut [ int ] = & mut [ 13 ] ;
905
+ assert ! ( a. tailn( 2 ) == b) ;
879
906
}
880
907
881
908
#[ test]
@@ -896,13 +923,30 @@ mod tests {
896
923
assert_eq ! ( a. init( ) , b) ;
897
924
}
898
925
926
+ #[ test]
927
+ fn test_init_mut ( ) {
928
+ let mut a = vec ! [ 11 i] ;
929
+ let b: & mut [ int ] = & mut [ ] ;
930
+ assert ! ( a. as_mut_slice( ) . init_mut( ) == b) ;
931
+ a = vec ! [ 11 i, 12 ] ;
932
+ let b: & mut [ int ] = & mut [ 11 ] ;
933
+ assert ! ( a. as_mut_slice( ) . init_mut( ) == b) ;
934
+ }
935
+
899
936
#[ test]
900
937
#[ should_fail]
901
938
fn test_init_empty ( ) {
902
939
let a: Vec < int > = vec ! [ ] ;
903
940
a. init ( ) ;
904
941
}
905
942
943
+ #[ test]
944
+ #[ should_fail]
945
+ fn test_init_mut_empty ( ) {
946
+ let mut a: Vec < int > = vec ! [ ] ;
947
+ a. as_mut_slice ( ) . init_mut ( ) ;
948
+ }
949
+
906
950
#[ test]
907
951
#[ allow( deprecated) ]
908
952
fn test_initn ( ) {
@@ -932,6 +976,16 @@ mod tests {
932
976
assert_eq ! ( a. as_slice( ) . last( ) . unwrap( ) , & 12 ) ;
933
977
}
934
978
979
+ #[ test]
980
+ fn test_last_mut ( ) {
981
+ let mut a = vec ! [ ] ;
982
+ assert_eq ! ( a. as_mut_slice( ) . last_mut( ) , None ) ;
983
+ a = vec ! [ 11 i] ;
984
+ assert_eq ! ( * a. as_mut_slice( ) . last_mut( ) . unwrap( ) , 11 ) ;
985
+ a = vec ! [ 11 i, 12 ] ;
986
+ assert_eq ! ( * a. as_mut_slice( ) . last_mut( ) . unwrap( ) , 12 ) ;
987
+ }
988
+
935
989
#[ test]
936
990
fn test_slice ( ) {
937
991
// Test fixed length vector.
@@ -1077,6 +1131,7 @@ mod tests {
1077
1131
}
1078
1132
1079
1133
#[ test]
1134
+ #[ allow( deprecated) ]
1080
1135
fn test_grow_set ( ) {
1081
1136
let mut v = vec ! [ 1 i, 2 , 3 ] ;
1082
1137
v. grow_set ( 4 u, & 4 , 5 ) ;
@@ -1610,6 +1665,7 @@ mod tests {
1610
1665
1611
1666
#[ test]
1612
1667
#[ should_fail]
1668
+ #[ allow( deprecated) ]
1613
1669
fn test_copy_memory_oob ( ) {
1614
1670
unsafe {
1615
1671
let mut a = [ 1 i, 2 , 3 , 4 ] ;
@@ -1793,6 +1849,26 @@ mod tests {
1793
1849
assert_eq ! ( xs. splitn( 1 , |x| * x == 5 ) . collect:: <Vec <& [ int] >>( ) . as_slice( ) , splits) ;
1794
1850
}
1795
1851
1852
+ #[ test]
1853
+ fn test_splitnator_mut ( ) {
1854
+ let xs = & mut [ 1 i, 2 , 3 , 4 , 5 ] ;
1855
+
1856
+ let splits: & [ & mut [ int ] ] = & [ & mut [ 1 , 2 , 3 , 4 , 5 ] ] ;
1857
+ assert_eq ! ( xs. splitn_mut( 0 , |x| * x % 2 == 0 ) . collect:: <Vec <& mut [ int] >>( ) . as_slice( ) ,
1858
+ splits) ;
1859
+ let splits: & [ & mut [ int ] ] = & [ & mut [ 1 ] , & mut [ 3 , 4 , 5 ] ] ;
1860
+ assert_eq ! ( xs. splitn_mut( 1 , |x| * x % 2 == 0 ) . collect:: <Vec <& mut [ int] >>( ) . as_slice( ) ,
1861
+ splits) ;
1862
+ let splits: & [ & mut [ int ] ] = & [ & mut [ ] , & mut [ ] , & mut [ ] , & mut [ 4 , 5 ] ] ;
1863
+ assert_eq ! ( xs. splitn_mut( 3 , |_| true ) . collect:: <Vec <& mut [ int] >>( ) . as_slice( ) ,
1864
+ splits) ;
1865
+
1866
+ let xs: & mut [ int ] = & mut [ ] ;
1867
+ let splits: & [ & mut [ int ] ] = & [ & mut [ ] ] ;
1868
+ assert_eq ! ( xs. splitn_mut( 1 , |x| * x == 5 ) . collect:: <Vec <& mut [ int] >>( ) . as_slice( ) ,
1869
+ splits) ;
1870
+ }
1871
+
1796
1872
#[ test]
1797
1873
fn test_rsplitator ( ) {
1798
1874
let xs = & [ 1 i, 2 , 3 , 4 , 5 ] ;
0 commit comments