Rename String.concat to operator+.

tests/standalone/io/file_test.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // Dart test program for testing file I/O.
 
 import 'dart:async';
 import 'dart:io';
 import 'dart:isolate';
 
@@ skipping 70 matching lines @@
     var file1 = new File(inFilename);
     List<int> buffer = new List<int>();
     file1.openRead().listen(
       (d) {
         buffer.addAll(d);
       },
       onDone: () {
         Expect.equals(42, buffer.length);
         // Write the contents of the file just read into another file.
         String outFilename =
-            tempDirectory.path.concat("/out_read_write_stream");
+            tempDirectory.path + "/out_read_write_stream";
         var file2 = new File(outFilename);
         var output = file2.openWrite();
         output.writeBytes(buffer);
         output.close();
         output.done.then((_) {
           // Now read the contents of the file just written.
           List<int> buffer2 = new List<int>();
           new File(outFilename).openRead().listen(
               (d) {
                 buffer2.addAll(d);
@@ skipping 17 matching lines @@
   // Test for file stream buffered handling of large files.
   static void testReadWriteStreamLargeFile() {
     asyncTestStarted();
 
     // Create the test data - arbitrary binary data.
     List<int> buffer = new List<int>(100000);
     for (var i = 0; i < buffer.length; ++i) {
       buffer[i] = i % 256;
     }
     String filename =
-        tempDirectory.path.concat("/out_read_write_stream_large_file");
+        tempDirectory.path + "/out_read_write_stream_large_file";
     File file = new File(filename);
     IOSink output = file.openWrite();
     output.writeBytes(buffer);
     output.writeBytes(buffer);
     output.close();
     output.done.then((_) {
       Stream input = file.openRead();
       int position = 0;
       final int expectedLength = 200000;
       // Start an independent asynchronous check on the length.
@@ skipping 121 matching lines @@
   static void testReadWrite() {
     // Read a file.
     String inFilename = getFilename("tests/vm/data/fixed_length_file");
     final File file = new File(inFilename);
     file.open(FileMode.READ).then((openedFile) {
       List<int> buffer1 = new List<int>(42);
       openedFile.readList(buffer1, 0, 42).then((bytes_read) {
         Expect.equals(42, bytes_read);
         openedFile.close().then((ignore) {
           // Write the contents of the file just read into another file.
-          String outFilename = tempDirectory.path.concat("/out_read_write");
+          String outFilename = tempDirectory.path + "/out_read_write";
           final File file2 = new File(outFilename);
           file2.create().then((ignore) {
             file2.fullPath().then((s) {
               Expect.isTrue(new File(s).existsSync());
               if (s[0] != '/' && s[0] != '\\' && s[1] != ':') {
                 Expect.fail("Not a full path");
               }
               file2.open(FileMode.WRITE).then((openedFile2) {
                 openedFile2.writeList(buffer1, 0, bytes_read).then((ignore) {
                   openedFile2.close().then((ignore) {
@@ skipping 26 matching lines @@
             });
           });
         });
       });
     });
     asyncTestStarted();
   }
 
   static void testWriteAppend() {
     String content = "foobar";
-    String filename = tempDirectory.path.concat("/write_append");
+    String filename = tempDirectory.path + "/write_append";
     File file = new File(filename);
     file.createSync();
     Expect.isTrue(new File(filename).existsSync());
     List<int> buffer = content.codeUnits;
     RandomAccessFile openedFile = file.openSync(FileMode.WRITE);
     openedFile.writeListSync(buffer, 0, buffer.length);
     openedFile.closeSync();
     // Reopen the file in write mode to ensure that we overwrite the content.
     openedFile = (new File(filename)).openSync(FileMode.WRITE);
     openedFile.writeListSync(buffer, 0, buffer.length);
     Expect.equals(content.length, openedFile.lengthSync());
     openedFile.closeSync();
     // Open the file in append mode and ensure that we do not overwrite
     // the existing content.
     openedFile = (new File(filename)).openSync(FileMode.APPEND);
     openedFile.writeListSync(buffer, 0, buffer.length);
     Expect.equals(content.length * 2, openedFile.lengthSync());
     openedFile.closeSync();
     file.deleteSync();
   }
 
   static void testOutputStreamWriteAppend() {
     String content = "foobar";
-    String filename = tempDirectory.path.concat("/outstream_write_append");
+    String filename = tempDirectory.path + "/outstream_write_append";
     File file = new File(filename);
     file.createSync();
     List<int> buffer = content.codeUnits;
     var output = file.openWrite();
     output.writeBytes(buffer);
     output.close();
     output.done.then((_) {
       File file2 = new File(filename);
       var appendingOutput = file2.openWrite(mode: FileMode.APPEND);
       appendingOutput.writeBytes(buffer);
@@ skipping 11 matching lines @@
           });
         });
       });
     });
     asyncTestStarted();
   }
 
   // Test for file read and write functionality.
   static void testOutputStreamWriteString() {
     String content = "foobar";
-    String filename = tempDirectory.path.concat("/outstream_write_string");
+    String filename = tempDirectory.path + "/outstream_write_string";
     File file = new File(filename);
     file.createSync();
     List<int> buffer = content.codeUnits;
     var output = file.openWrite();
     output.write("abcdABCD");
     output.encoding = Encoding.UTF_8;
     output.write("abcdABCD");
     output.encoding = Encoding.ISO_8859_1;
     output.write("abcdABCD");
     output.encoding = Encoding.ASCII;
@@ skipping 16 matching lines @@
     // Read a file.
     String inFilename = getFilename("tests/vm/data/fixed_length_file");
     RandomAccessFile file = (new File(inFilename)).openSync();
     List<int> buffer1 = new List<int>(42);
     int bytes_read = 0;
     int bytes_written = 0;
     bytes_read = file.readListSync(buffer1, 0, 42);
     Expect.equals(42, bytes_read);
     file.closeSync();
     // Write the contents of the file just read into another file.
-    String outFilename = tempDirectory.path.concat("/out_read_write_sync");
+    String outFilename = tempDirectory.path + "/out_read_write_sync";
     File outFile = new File(outFilename);
     outFile.createSync();
     String path = outFile.fullPathSync();
     if (path[0] != '/' && path[0] != '\\' && path[1] != ':') {
       Expect.fail("Not a full path");
     }
     Expect.isTrue(new File(path).existsSync());
     RandomAccessFile openedFile = outFile.openSync(FileMode.WRITE);
     openedFile.writeListSync(buffer1, 0, bytes_read);
     openedFile.closeSync();
     // Now read the contents of the file just written.
     List<int> buffer2 = new List<int>(bytes_read);
     openedFile = (new File(outFilename)).openSync();
     bytes_read = openedFile.readListSync(buffer2, 0, 42);
     Expect.equals(42, bytes_read);
     openedFile.closeSync();
     // Now compare the two buffers to check if they are identical.
     Expect.equals(buffer1.length, buffer2.length);
     for (int i = 0; i < buffer1.length; i++) {
       Expect.equals(buffer1[i],  buffer2[i]);
     }
     // Delete the output file.
     outFile.deleteSync();
     Expect.isFalse(outFile.existsSync());
   }
 
   static void testReadEmptyFileSync() {
-    String fileName = tempDirectory.path.concat("/empty_file_sync");
+    String fileName = tempDirectory.path + "/empty_file_sync";
     File file = new File(fileName);
     file.createSync();
     RandomAccessFile openedFile = file.openSync();
     Expect.equals(-1, openedFile.readByteSync());
     openedFile.closeSync();
     file.deleteSync();
   }
 
   static void testReadEmptyFile() {
-    String fileName = tempDirectory.path.concat("/empty_file");
+    String fileName = tempDirectory.path + "/empty_file";
     File file = new File(fileName);
     asyncTestStarted();
     file.create().then((ignore) {
       file.open(FileMode.READ).then((RandomAccessFile openedFile) {
         var readByteFuture = openedFile.readByte();
         readByteFuture.then((int byte) {
           Expect.equals(-1, byte);
           openedFile.close().then((ignore) {
             asyncTestDone("testReadEmptyFile");
           });
@@ skipping 160 matching lines @@
     input.readListSync(buffer, 0, 12);
     Expect.equals(12, input.positionSync());
     input.readListSync(buffer, 12, 6);
     Expect.equals(18, input.positionSync());
     input.setPositionSync(8);
     Expect.equals(8, input.positionSync());
     input.closeSync();
   }
 
   static void testTruncate() {
-    File file = new File(tempDirectory.path.concat("/out_truncate"));
+    File file = new File(tempDirectory.path + "/out_truncate");
     List buffer = const [65, 65, 65, 65, 65, 65, 65, 65, 65, 65];
     file.open(FileMode.WRITE).then((RandomAccessFile openedFile) {
       openedFile.writeList(buffer, 0, 10).then((ignore) {
         openedFile.length().then((length) {
           Expect.equals(10, length);
           openedFile.truncate(5).then((ignore) {
             openedFile.length().then((length) {
               Expect.equals(5, length);
               openedFile.close().then((ignore) {
                 file.delete().then((ignore) {
                   file.exists().then((exists) {
                     Expect.isFalse(exists);
                     asyncTestDone("testTruncate");
                   });
                 });
               });
             });
           });
         });
       });
     });
     asyncTestStarted();
   }
 
   static void testTruncateSync() {
-    File file = new File(tempDirectory.path.concat("/out_truncate_sync"));
+    File file = new File(tempDirectory.path + "/out_truncate_sync");
     List buffer = const [65, 65, 65, 65, 65, 65, 65, 65, 65, 65];
     RandomAccessFile openedFile = file.openSync(FileMode.WRITE);
     openedFile.writeListSync(buffer, 0, 10);
     Expect.equals(10, openedFile.lengthSync());
     openedFile.truncateSync(5);
     Expect.equals(5, openedFile.lengthSync());
     openedFile.closeSync();
     file.deleteSync();
     Expect.isFalse(file.existsSync());
   }
 
   // Tests exception handling after file was closed.
   static void testCloseException() {
     bool exceptionCaught = false;
     bool wrongExceptionCaught = false;
-    File input = new File(tempDirectory.path.concat("/out_close_exception"));
+    File input = new File(tempDirectory.path + "/out_close_exception");
     RandomAccessFile openedFile = input.openSync(FileMode.WRITE);
     openedFile.closeSync();
     try {
       openedFile.readByteSync();
     } on FileIOException catch (ex) {
       exceptionCaught = true;
     } on Exception catch (ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
@@ skipping 71 matching lines @@
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     input.deleteSync();
   }
 
   // Tests stream exception handling after file was closed.
   static void testCloseExceptionStream() {
     asyncTestStarted();
     List<int> buffer = new List<int>(42);
     File file =
-        new File(tempDirectory.path.concat("/out_close_exception_stream"));
+        new File(tempDirectory.path + "/out_close_exception_stream");
     file.createSync();
     var output = file.openWrite();
     output.close();
     Expect.throws(() => output.writeBytes(buffer));
     output.done.then((_) {
       file.deleteSync();
       asyncTestDone("testCloseExceptionStream");
     });
   }
 
   // Tests buffer out of bounds exception.
   static void testBufferOutOfBoundsException() {
     bool exceptionCaught = false;
     bool wrongExceptionCaught = false;
     File file =
-        new File(tempDirectory.path.concat("/out_buffer_out_of_bounds"));
+        new File(tempDirectory.path + "/out_buffer_out_of_bounds");
     RandomAccessFile openedFile = file.openSync(FileMode.WRITE);
     try {
       List<int> buffer = new List<int>(10);
       openedFile.readListSync(buffer, 0, 12);
     } on RangeError catch (ex) {
       exceptionCaught = true;
     } on Exception catch (ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
@@ skipping 445 matching lines @@
       testDirectorySync();
       testWriteStringUtf8();
       testWriteStringUtf8Sync();
     });
   }
 }
 
 main() {
   FileTest.testMain();
 }