@@ -1204,22 +1204,16 @@ fn test_from_iter_specialization_with_iterator_adapters() {
12041204#[ test]
12051205fn test_in_place_specialization_step_up_down ( ) {
12061206 fn assert_in_place_trait < T : InPlaceIterable > ( _: & T ) { }
1207- let src = vec ! [ [ 0u8 ; 4 ] ; 256 ] ;
1208- let srcptr = src. as_ptr ( ) ;
1209- let src_cap = src. capacity ( ) ;
1210- let iter = src. into_iter ( ) . flatten ( ) ;
1211- assert_in_place_trait ( & iter) ;
1212- let sink = iter. collect :: < Vec < _ > > ( ) ;
1213- let sinkptr = sink. as_ptr ( ) ;
1214- assert_eq ! ( srcptr as * const u8 , sinkptr) ;
1215- assert_eq ! ( src_cap * 4 , sink. capacity( ) ) ;
12161207
1217- let iter = sink. into_iter ( ) . array_chunks :: < 4 > ( ) ;
1208+ let src = vec ! [ 0u8 ; 1024 ] ;
1209+ let srcptr = src. as_ptr ( ) ;
1210+ let src_bytes = src. capacity ( ) ;
1211+ let iter = src. into_iter ( ) . array_chunks :: < 4 > ( ) ;
12181212 assert_in_place_trait ( & iter) ;
12191213 let sink = iter. collect :: < Vec < _ > > ( ) ;
12201214 let sinkptr = sink. as_ptr ( ) ;
1221- assert_eq ! ( srcptr, sinkptr) ;
1222- assert_eq ! ( src_cap , sink. capacity( ) ) ;
1215+ assert_eq ! ( srcptr. addr ( ) , sinkptr. addr ( ) ) ;
1216+ assert_eq ! ( src_bytes , sink. capacity( ) * 4 ) ;
12231217
12241218 let mut src: Vec < u8 > = Vec :: with_capacity ( 17 ) ;
12251219 let src_bytes = src. capacity ( ) ;
@@ -1236,13 +1230,6 @@ fn test_in_place_specialization_step_up_down() {
12361230 let sink: Vec < [ u8 ; 2 ] > = iter. collect ( ) ;
12371231 assert_eq ! ( sink. len( ) , 8 ) ;
12381232 assert ! ( sink. capacity( ) <= 25 ) ;
1239-
1240- let src = vec ! [ [ 0u8 ; 4 ] ; 256 ] ;
1241- let srcptr = src. as_ptr ( ) ;
1242- let iter = src. into_iter ( ) . flat_map ( |a| a. into_iter ( ) . map ( |b| b. wrapping_add ( 1 ) ) ) ;
1243- assert_in_place_trait ( & iter) ;
1244- let sink = iter. collect :: < Vec < _ > > ( ) ;
1245- assert_eq ! ( srcptr as * const u8 , sink. as_ptr( ) ) ;
12461233}
12471234
12481235#[ test]
@@ -1350,6 +1337,20 @@ fn test_collect_after_iterator_clone() {
13501337 assert_eq ! ( v, [ 1 , 1 , 1 , 1 , 1 ] ) ;
13511338 assert ! ( v. len( ) <= v. capacity( ) ) ;
13521339}
1340+
1341+ // regression test for #135103, similar to the one above Flatten/FlatMap had an unsound InPlaceIterable
1342+ // implementation.
1343+ #[ test]
1344+ fn test_flatten_clone ( ) {
1345+ const S : String = String :: new ( ) ;
1346+
1347+ let v = vec ! [ [ S , "Hello World!" . into( ) ] , [ S , S ] ] ;
1348+ let mut i = v. into_iter ( ) . flatten ( ) ;
1349+ let _ = i. next ( ) ;
1350+ let result: Vec < String > = i. clone ( ) . collect ( ) ;
1351+ assert_eq ! ( result, [ "Hello World!" , "" , "" ] ) ;
1352+ }
1353+
13531354#[ test]
13541355fn test_cow_from ( ) {
13551356 let borrowed: & [ _ ] = & [ "borrowed" , "(slice)" ] ;
0 commit comments