More String + elimination in tests

tests/standalone/io/file_test.dart

 // Copyright (c) 2012, 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:io");
 #import("dart:isolate");
 
 class MyListOfOneElement implements List {
@@ skipping 97 matching lines @@
 
           // Test reading all using read.
           file = new File(inFilename);
           input = file.openInputStream();
           input.onData = () {
             buffer1 = input.read();
             Expect.equals(42, buffer1.length);
             Expect.isTrue(input.closed);
 
             // Write the contents of the file just read into another file.
-            String outFilename = tempDirectory.path + "/out_read_write_stream";
+            String outFilename =
+                tempDirectory.path.concat("/out_read_write_stream");
             file = new File(outFilename);
             OutputStream output = file.openOutputStream();
             bool writeDone = output.writeFrom(buffer1, 0, 42);
             Expect.equals(false, writeDone);
             output.onNoPendingWrites = () {
               output.close();
               output.onClosed = () {
                 // Now read the contents of the file just written.
                 List<int> buffer2 = new List<int>(42);
                 file = new File(outFilename);
@@ skipping 75 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 + "/out_read_write";
+          String outFilename = tempDirectory.path.concat("/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 + "/write_append";
+    String filename = tempDirectory.path.concat("/write_append");
     File file = new File(filename);
     file.createSync();
     Expect.isTrue(new File(filename).existsSync());
     List<int> buffer = content.charCodes();
     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 + "/outstream_write_append";
+    String filename = tempDirectory.path.concat("/outstream_write_append");
     File file = new File(filename);
     file.createSync();
     List<int> buffer = content.charCodes();
     OutputStream outStream = file.openOutputStream();
     outStream.write(buffer);
     outStream.onNoPendingWrites = () {
       outStream.close();
       outStream.onClosed = () {
         File file2 = new File(filename);
         OutputStream appendingOutput =
@@ skipping 16 matching lines @@
           };
         };
       };
     };
     asyncTestStarted();
   }
 
   // Test for file read and write functionality.
   static void testOutputStreamWriteString() {
     String content = "foobar";
-    String filename = tempDirectory.path + "/outstream_write_string";
+    String filename = tempDirectory.path.concat("/outstream_write_string");
     File file = new File(filename);
     file.createSync();
     List<int> buffer = content.charCodes();
     OutputStream outStream = file.openOutputStream();
     outStream.writeString("abcdABCD");
     outStream.writeString("abcdABCD", Encoding.UTF_8);
     outStream.writeString("abcdABCD", Encoding.ISO_8859_1);
     outStream.writeString("abcdABCD", Encoding.ASCII);
     outStream.writeString("æøå", Encoding.UTF_8);
     outStream.onNoPendingWrites = () {
@@ skipping 14 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 + "/out_read_write_sync";
+    String outFilename = tempDirectory.path.concat("/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 + "/empty_file_sync";
+    String fileName = tempDirectory.path.concat("/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 + "/empty_file";
+    String fileName = tempDirectory.path.concat("/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 163 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 + "/out_truncate");
+    File file = new File(tempDirectory.path.concat("/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 + "/out_truncate_sync");
+    File file = new File(tempDirectory.path.concat("/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 + "/out_close_exception");
+    File input = new File(tempDirectory.path.concat("/out_close_exception"));
     RandomAccessFile openedFile = input.openSync(FileMode.WRITE);
     openedFile.closeSync();
     try {
       openedFile.readByteSync();
     } catch (FileIOException ex) {
       exceptionCaught = true;
     } catch (Exception ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
@@ skipping 70 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 + "/out_close_exception_stream");
+    File file =
+        new File(tempDirectory.path.concat("/out_close_exception_stream"));
     file.createSync();
     InputStream input = file.openInputStream();
     input.onClosed = () {
       Expect.isTrue(input.closed);
       Expect.isNull(input.readInto(buffer, 0, 12));
       OutputStream output = file.openOutputStream();
       output.close();
       Expect.throws(() => output.writeFrom(buffer, 0, 12));
       output.onClosed = () {
         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 + "/out_buffer_out_of_bounds");
+    File file =
+        new File(tempDirectory.path.concat("/out_buffer_out_of_bounds"));
     RandomAccessFile openedFile = file.openSync(FileMode.WRITE);
     try {
       List<int> buffer = new List<int>(10);
       openedFile.readListSync(buffer, 0, 12);
     } catch (IndexOutOfRangeException ex) {
       exceptionCaught = true;
     } catch (Exception ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
@@ skipping 267 matching lines @@
     openedFile.writeStringSync("asdf");
     Expect.equals(8, openedFile.lengthSync());
     openedFile.closeSync();
     file.deleteSync();
     Expect.isFalse(file.existsSync());
   }
 
   // Helper method to be able to run the test from the runtime
   // directory, or the top directory.
   static String getFilename(String path) =>
-      new File(path).existsSync() ? path : 'runtime/' + path;
+      new File(path).existsSync() ? path : 'runtime/$path';
 
   static String getDataFilename(String path) =>
-      new File(path).existsSync() ? path : '../' + path;
+      new File(path).existsSync() ? path : '../$path';
 
   // Main test entrypoint.
   static testMain() {
     port = new ReceivePort();
     testRead();
     testReadSync();
     testReadStream();
     testLength();
     testLengthSync();
     testPosition();
@@ skipping 27 matching lines @@
       testWriteVariousLists();
       testDirectory();
       testDirectorySync();
     });
   }
 }
 
 main() {
   FileTest.testMain();
 }