X-Git-Url: https://git.mdrn.pl/pylucene.git/blobdiff_plain/a2e61f0c04805cfcb8706176758d1283c7e3a55c..aaeed5504b982cf3545252ab528713250aa33eed:/lucene-java-3.5.0/lucene/src/test/org/apache/lucene/store/TestCopyBytes.java

diff --git a/lucene-java-3.5.0/lucene/src/test/org/apache/lucene/store/TestCopyBytes.java b/lucene-java-3.5.0/lucene/src/test/org/apache/lucene/store/TestCopyBytes.java
new file mode 100644
index 0000000..75151df
--- /dev/null
+++ b/lucene-java-3.5.0/lucene/src/test/org/apache/lucene/store/TestCopyBytes.java
@@ -0,0 +1,172 @@
+package org.apache.lucene.store;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.io.IOException;
+
+import org.apache.lucene.util.LuceneTestCase;
+import org.apache.lucene.util._TestUtil;
+
+import org.junit.Test;
+
+public class TestCopyBytes extends LuceneTestCase {
+
+  private byte value(int idx) {
+    return (byte) ((idx%256) * (1+(idx/256)));
+  }
+
+
+  @Test
+  public void testCopyBytes() throws Exception {
+    int num = atLeast(10);
+    for(int iter=0;iter<num;iter++) {
+      Directory dir = newDirectory();
+      if (VERBOSE) {
+        System.out.println("TEST: iter=" + iter + " dir=" + dir);
+      }
+
+      // make random file
+      IndexOutput out = dir.createOutput("test");
+      byte[] bytes = new byte[_TestUtil.nextInt(random, 1, 77777)];
+      final int size = _TestUtil.nextInt(random, 1, 1777777);
+      int upto = 0;
+      int byteUpto = 0;
+      while(upto < size) {
+        bytes[byteUpto++] = value(upto);
+        upto++;
+        if (byteUpto == bytes.length) {
+          out.writeBytes(bytes, 0, bytes.length);
+          byteUpto = 0;
+        }
+      }
+
+      out.writeBytes(bytes, 0, byteUpto);
+      assertEquals(size, out.getFilePointer());
+      out.close();
+      assertEquals(size, dir.fileLength("test"));
+
+      // copy from test -> test2
+      final IndexInput in = dir.openInput("test");
+
+      out = dir.createOutput("test2");
+
+      upto = 0;
+      while(upto < size) {
+        if (random.nextBoolean()) {
+          out.writeByte(in.readByte());
+          upto++;
+        } else {
+          final int chunk = Math.min(_TestUtil.nextInt(random, 1, bytes.length), size-upto);
+          out.copyBytes(in, chunk);
+          upto += chunk;
+        }
+      }
+      assertEquals(size, upto);
+      out.close();
+      in.close();
+
+      // verify
+      IndexInput in2 = dir.openInput("test2");
+      upto = 0;
+      while(upto < size) {
+        if (random.nextBoolean()) {
+          final byte v = in2.readByte();
+          assertEquals(value(upto), v);
+          upto++;
+        } else {
+          final int limit = Math.min(_TestUtil.nextInt(random, 1, bytes.length), size-upto);
+          in2.readBytes(bytes, 0, limit);
+          for(int byteIdx=0;byteIdx<limit;byteIdx++) {
+            assertEquals(value(upto), bytes[byteIdx]);
+            upto++;
+          }
+        }
+      }
+      in2.close();
+
+      dir.deleteFile("test");
+      dir.deleteFile("test2");
+      
+      dir.close();
+    }
+  }
+  
+  // LUCENE-3541
+  public void testCopyBytesWithThreads() throws Exception {
+    int datalen = _TestUtil.nextInt(random, 101, 10000);
+    byte data[] = new byte[datalen];
+    random.nextBytes(data);
+    
+    Directory d = newDirectory();
+    IndexOutput output = d.createOutput("data");
+    output.writeBytes(data, 0, datalen);
+    output.close();
+    
+    IndexInput input = d.openInput("data");
+    IndexOutput outputHeader = d.createOutput("header");
+    // copy our 100-byte header
+    input.copyBytes(outputHeader, 100);
+    outputHeader.close();
+    
+    // now make N copies of the remaining bytes
+    CopyThread copies[] = new CopyThread[10];
+    for (int i = 0; i < copies.length; i++) {
+      copies[i] = new CopyThread((IndexInput) input.clone(), d.createOutput("copy" + i));
+    }
+    
+    for (int i = 0; i < copies.length; i++) {
+      copies[i].start();
+    }
+    
+    for (int i = 0; i < copies.length; i++) {
+      copies[i].join();
+    }
+    
+    for (int i = 0; i < copies.length; i++) {
+      IndexInput copiedData = d.openInput("copy" + i);
+      byte[] dataCopy = new byte[datalen];
+      System.arraycopy(data, 0, dataCopy, 0, 100); // copy the header for easy testing
+      copiedData.readBytes(dataCopy, 100, datalen-100);
+      assertArrayEquals(data, dataCopy);
+      copiedData.close();
+    }
+    input.close();
+    d.close();
+    
+  }
+  
+  static class CopyThread extends Thread {
+    final IndexInput src;
+    final IndexOutput dst;
+    
+    CopyThread(IndexInput src, IndexOutput dst) {
+      this.src = src;
+      this.dst = dst;
+    }
+
+    @Override
+    public void run() {
+      try {
+        src.copyBytes(dst, src.length()-100);
+        dst.close();
+      } catch (IOException ex) {
+        throw new RuntimeException(ex);
+      }
+    }
+  }
+}