| /******************************************************************************* |
| * Copyright (c) 2000, 2015 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.core.tests.internal.watson; |
| |
| import java.io.*; |
| import org.eclipse.core.internal.watson.*; |
| import org.eclipse.core.runtime.IPath; |
| |
| public abstract class ElementTreeSerializationTest extends WatsonTest implements IPathConstants { |
| |
| protected ElementTree fTree; |
| |
| String root = System.getProperty("java.io.tmpdir"); |
| protected File tempFile = new File(root + "/temp/TestFlattening"); |
| |
| class WriterThread implements Runnable { |
| DataOutputStream fDataOutputStream; |
| ElementTreeWriter fWriter; |
| |
| public void setStream(DataOutputStream stream) { |
| fDataOutputStream = stream; |
| } |
| |
| public void setWriter(ElementTreeWriter writer) { |
| fWriter = writer; |
| } |
| |
| @Override |
| public void run() { |
| try { |
| doWrite(fWriter, fDataOutputStream); |
| } catch (IOException e) { |
| assertTrue("Error writing delta", false); |
| e.printStackTrace(); |
| } |
| } |
| } |
| |
| class ReaderThread implements Runnable { |
| DataInputStream fDataInputStream; |
| ElementTreeReader fReader; |
| Object fRefried; |
| |
| public void setStream(DataInputStream stream) { |
| fDataInputStream = stream; |
| } |
| |
| public void setReader(ElementTreeReader reader) { |
| fReader = reader; |
| } |
| |
| public Object getReconstitutedObject() { |
| return fRefried; |
| } |
| |
| @Override |
| public void run() { |
| try { |
| fRefried = doRead(fReader, fDataInputStream); |
| } catch (IOException e) { |
| assertTrue("Error reading delta", false); |
| e.printStackTrace(); |
| } |
| } |
| } |
| |
| WriterThread writerThread = new WriterThread(); |
| ReaderThread readerThread = new ReaderThread(); |
| |
| /** |
| * The subtree to write |
| */ |
| protected IPath fSubtreePath; |
| |
| /** |
| * The depth of the tree to write. |
| */ |
| protected int fDepth; |
| |
| public ElementTreeSerializationTest() { |
| super(null); |
| } |
| |
| /** |
| * ElementTreeSerializationTests constructor comment. |
| * @param name java.lang.String |
| */ |
| public ElementTreeSerializationTest(String name) { |
| super(name); |
| } |
| |
| /** |
| * Performs exhaustive tests for all subtrees and all depths |
| */ |
| protected void doExhaustiveTests() { |
| IPath[] paths = TestUtil.getTreePaths(); |
| int[] depths = getTreeDepths(); |
| |
| for (IPath path : paths) { |
| for (int depth : depths) { |
| doTest(path, depth); |
| } |
| } |
| } |
| |
| /** |
| * Write a flattened element tree to a file and read it back. |
| */ |
| public Object doFileTest() { |
| IElementInfoFlattener fac = getFlattener(); |
| |
| Object newTree = null; |
| ElementTreeWriter writer = new ElementTreeWriter(fac); |
| ElementTreeReader reader = new ElementTreeReader(fac); |
| FileOutputStream fos = null; |
| FileInputStream fis = null; |
| DataOutputStream dos = null; |
| DataInputStream dis = null; |
| |
| /* Write the element tree. */ |
| try { |
| File dir = tempFile.getParentFile(); |
| dir.mkdirs(); |
| fos = new FileOutputStream(tempFile); |
| dos = new DataOutputStream(fos); |
| } catch (IOException e) { |
| e.printStackTrace(); |
| assertTrue("Unable to open ouput file", false); |
| } |
| try { |
| doWrite(writer, dos); |
| } catch (IOException e) { |
| e.printStackTrace(); |
| assertTrue("Error writing tree to file", false); |
| } finally { |
| try { |
| dos.flush(); |
| fos.close(); |
| } catch (IOException e) { |
| e.printStackTrace(); |
| assertTrue("Unable to close output file!", false); |
| } |
| } |
| |
| /* Read the element tree. */ |
| try { |
| fis = new FileInputStream(tempFile); |
| dis = new DataInputStream(fis); |
| } catch (IOException e) { |
| e.printStackTrace(); |
| assertTrue("Unable to open input file", false); |
| } |
| try { |
| newTree = doRead(reader, dis); |
| } catch (IOException e) { |
| e.printStackTrace(); |
| assertTrue("Error reading tree from file", false); |
| } finally { |
| try { |
| fis.close(); |
| } catch (IOException e) { |
| e.printStackTrace(); |
| assertTrue("Unable to close input file!", false); |
| } |
| } |
| return newTree; |
| } |
| |
| /** Pipe a flattened element tree from writer to reader threads. |
| */ |
| public Object doPipeTest() { |
| IElementInfoFlattener fac = getFlattener(); |
| Object refried = null; |
| ElementTreeWriter w = new ElementTreeWriter(fac); |
| ElementTreeReader r = new ElementTreeReader(fac); |
| PipedOutputStream pout; |
| PipedInputStream pin; |
| DataOutputStream oos; |
| DataInputStream ois; |
| |
| /* Pipe the element tree from writer to reader threads. */ |
| try { |
| pout = new PipedOutputStream(); |
| pin = new PipedInputStream(pout); |
| oos = new DataOutputStream(pout); //new FileOutputStream(FILE_NAME)); |
| ois = new DataInputStream(pin); |
| writerThread.setStream(oos); |
| readerThread.setStream(ois); |
| writerThread.setWriter(w); |
| readerThread.setReader(r); |
| Thread thread1 = new Thread(writerThread); |
| Thread thread2 = new Thread(readerThread); |
| thread1.start(); |
| thread2.start(); |
| while (thread2.isAlive()) { |
| try { |
| thread2.join(); |
| } catch (InterruptedException excp) { |
| } |
| } |
| refried = readerThread.getReconstitutedObject(); |
| ois.close(); |
| oos.close(); |
| } catch (IOException e) { |
| e.printStackTrace(); |
| assertTrue("Unable to open stream:", false); |
| } |
| return refried; |
| } |
| |
| /** |
| * Performs the serialization activity for this test |
| */ |
| public abstract Object doRead(ElementTreeReader reader, DataInputStream input) throws IOException; |
| |
| /** |
| * Runs a test for this class at a certain depth and path |
| */ |
| public abstract void doTest(IPath path, int depth); |
| |
| /** |
| * Performs the serialization activity for this test |
| */ |
| public abstract void doWrite(ElementTreeWriter writer, DataOutputStream output) throws IOException; |
| |
| /** |
| * Tests the reading and writing of element deltas |
| */ |
| public IElementInfoFlattener getFlattener() { |
| return new IElementInfoFlattener() { |
| @Override |
| public void writeElement(IPath path, Object data, DataOutput output) throws IOException { |
| if (data == null) { |
| output.writeUTF("null"); |
| } else { |
| output.writeUTF((String) data); |
| } |
| } |
| |
| @Override |
| public Object readElement(IPath path, DataInput input) throws IOException { |
| String data = input.readUTF(); |
| if ("null".equals(data)) { |
| return null; |
| } else { |
| return data; |
| } |
| } |
| }; |
| } |
| |
| /** |
| * Returns all the different possible depth values for this tree. |
| * To be conservative, it is okay if some of the returned depths |
| * are not possible. |
| */ |
| protected int[] getTreeDepths() { |
| return new int[] {-1, 0, 1, 2, 3, 4}; |
| } |
| |
| @Override |
| protected void setUp() throws Exception { |
| fTree = TestUtil.createTestElementTree(); |
| /* default subtree we are interested in */ |
| fSubtreePath = solution; |
| |
| /* default depth is the whole tree */ |
| fDepth = ElementTreeWriter.D_INFINITE; |
| } |
| |
| /** |
| * |
| */ |
| @Override |
| protected void tearDown() throws Exception { |
| //ElementTree tests don't use the CoreTest infrastructure |
| tempFile.delete(); |
| } |
| } |