@@ -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