[Rubyeclipse-commit] org.rubypeople.rdt.debug.core.tests/src/org/rubypeople/rdt/debug/core/tests FTC

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/rubyeclipse/org.rubypeople.rdt.debug.core.tests/src/org/rubypeople/rdt/debug/core/tests
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv24526/src/org/rubypeople/rdt/debug/core/tests

Modified Files:
	FTC_DebuggerLaunch.java 
Added Files:
	FTC_DebuggerCommunicationTest.java FTS_Debug.java 
	FTC_ReadStrategyTest.java FTC_DebuggerProxyTest.java 
Removed Files:
	TC_ReadStrategyTest.java TC_DebuggerCommunicationTest.java 
	TC_DebuggerProxyTest.java TS_Debug.java 
Log Message:
Organize tests for consistency.  Found a few TCs that weren't being called for the main suite.

--- TC_DebuggerProxyTest.java DELETED ---

--- TC_DebuggerCommunicationTest.java DELETED ---

--- NEW FILE: FTC_ReadStrategyTest.java ---
package org.rubypeople.rdt.debug.core.tests;

import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.PrintWriter;

import junit.framework.TestCase;

import org.rubypeople.rdt.internal.debug.core.parsing.MultiReaderStrategy;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserFactory;

public class FTC_ReadStrategyTest extends TestCase {

	protected PrintWriter writer ;
	protected XmlPullParser xpp ;

	public FTC_ReadStrategyTest(String name) {
		super(name);
	}

	public void setUp() throws Exception {
		XmlPullParserFactory factory = XmlPullParserFactory.newInstance("org.kxml2.io.KXmlParser,org.kxml2.io.KXmlSerializer", null);
		xpp = factory.newPullParser();
		PipedOutputStream outputStream = new PipedOutputStream() ;
		PipedInputStream inputStream = new PipedInputStream(outputStream) ;
		xpp.setInput(new InputStreamReader(inputStream)) ;
		writer = new PrintWriter(new OutputStreamWriter(outputStream)) ;			
	}

	public void testSingleReaderStrategy() throws Exception {
		final TestXmlStreamReader reader = new TestXmlStreamReader(xpp) ;
		reader.acceptTag("testTag") ;
		Thread testTagReaderThread = new Thread() {
			public void run() {
				try {
					reader.read() ;
				} catch (Exception ex) {

				}
			}
		} ;
		testTagReaderThread.start() ;
		writer.println("<testTag/>") ;
		writer.flush() ;		 
		testTagReaderThread.join() ;
		assertTrue("testTag", reader.isTagRead()) ;
	}

	public void testMultiReaderStrategy() throws Exception {
		MultiReaderStrategy multiReaderStrategy = new MultiReaderStrategy(xpp) ;
		final TestXmlStreamReader testTagReader = new TestXmlStreamReader(multiReaderStrategy) ;
		testTagReader.acceptTag("testTag") ;
		Thread testTagReaderThread = new Thread() {
			public void run() {
				try {
					testTagReader.read() ;
				} catch (Exception ex) {

				}
			}
		} ;
		testTagReaderThread.start() ;
		final TestXmlStreamReader breakpointReader = new TestXmlStreamReader(multiReaderStrategy) ;
		breakpointReader.acceptTag("breakpoint") ;
		Thread breakpointReaderThread = new Thread() {
			public void run() {
				try {
					breakpointReader.read() ;
				} catch (Exception ex) {

				}

			}
		} ;
		breakpointReaderThread.start() ;
		Thread.sleep(500) ; // wait for threads to be started
		assertTrue(testTagReaderThread.isAlive()) ;
		assertTrue(breakpointReaderThread.isAlive()) ;

		writer.println("<testTag/>") ;
		writer.flush() ;
		testTagReaderThread.join() ;		 
		assertTrue("testTag was read.", testTagReader.isTagRead()) ;
		assertTrue("breakpoint was not yet read.", !breakpointReader.isTagRead()) ;		
		assertTrue("breakpointReaderThread has not yet finished.",breakpointReaderThread.isAlive()) ; 
		writer.println("<breakpoint/>") ;
		writer.flush() ;		 
		breakpointReaderThread.join() ;
		assertTrue("breakpoint was read.", breakpointReader.isTagRead()) ;		

	}

	public void testMultiReaderStrategyWithMultipleTags() throws Exception {
		// make sure that a complete element gets dispatched to the reader
		MultiReaderStrategy multiReaderStrategy = new MultiReaderStrategy(xpp);
		final TestXmlStreamReader testTagReader = new TestXmlStreamReader(multiReaderStrategy) ;
		testTagReader.acceptTag("testTag");
		Thread testTagReaderThread = new Thread() {
			public void run() {
				try {
					testTagReader.read() ;
				} catch (Exception ex) {

				}
			}
		} ;
		testTagReaderThread.start();
		Thread.sleep(500); // wait for threads to be started
		writer.println("<testTag><testTag><testTag/><testTag/></testTag>") ;
		writer.flush() ;
		testTagReaderThread.join();		 
		assertEquals("testTag was read 3 times.", 3, testTagReader.getTagReadCount());		
	}

	public void testMultiReaderStrategyDontMissTag() throws Exception {
		// make sure the element is delivered to the reader, even if the reader is started after
		// the tag is fetched from the xpp 
		writer.println("<testTag><testTag/></testTag>") ;
		writer.flush() ;
		MultiReaderStrategy multiReaderStrategy = new MultiReaderStrategy(xpp) ;
		final TestXmlStreamReader testTagReader = new TestXmlStreamReader(multiReaderStrategy) ;
		testTagReader.acceptTag("testTag") ;
		Thread testTagReaderThread = new Thread() {
			public void run() {
				try {
					testTagReader.read() ;
				} catch (Exception ex) {
					fail() ;
				}
			}
		} ;
		Thread.sleep(500) ; // wait to make this test more evil
		testTagReaderThread.start() ;
		Thread.sleep(500) ; // wait for threads to be started				
		testTagReaderThread.join() ;		 
		assertEquals("testTag was read 2 times.", 2, testTagReader.getTagReadCount()) ;		
	}

}

--- NEW FILE: FTS_Debug.java ---
package org.rubypeople.rdt.debug.core.tests;
import junit.framework.Test;
import junit.framework.TestSuite;

public class FTS_Debug {

	public static Test suite() {
		TestSuite suite = new TestSuite();

		suite.addTestSuite(FTC_DebuggerCommunicationTest.class);
		suite.addTestSuite(FTC_DebuggerProxyTest.class) ;
		suite.addTestSuite(FTC_ReadStrategyTest.class) ;
		suite.addTestSuite(FTC_DebuggerLaunch.class) ;
		return suite;
	}
}
Index: FTC_DebuggerLaunch.java
===================================================================
RCS file: /cvsroot/rubyeclipse/org.rubypeople.rdt.debug.core.tests/src/org/rubypeople/rdt/debug/core/tests/FTC_DebuggerLaunch.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** FTC_DebuggerLaunch.java	9 Oct 2005 21:22:19 -0000	1.1
--- FTC_DebuggerLaunch.java	16 Oct 2005 23:52:50 -0000	1.2
***************
*** 35,39 ****

! 		RubyInterpreter rubyInterpreter = new RubyInterpreter("RubyInterpreter", new Path(TC_DebuggerCommunicationTest.RUBY_INTERPRETER));
  		RubyRuntime.getDefault().addInstalledInterpreter(rubyInterpreter) ;

--- 35,39 ----

! 		RubyInterpreter rubyInterpreter = new RubyInterpreter("RubyInterpreter", new Path(FTC_DebuggerCommunicationTest.RUBY_INTERPRETER));
  		RubyRuntime.getDefault().addInstalledInterpreter(rubyInterpreter) ;

--- NEW FILE: FTC_DebuggerCommunicationTest.java ---
package org.rubypeople.rdt.debug.core.tests;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ConnectException;
import java.net.Socket;

import junit.framework.TestCase;

import org.rubypeople.rdt.core.RubyCore;
import org.rubypeople.rdt.internal.debug.core.ExceptionSuspensionPoint;
import org.rubypeople.rdt.internal.debug.core.StepSuspensionPoint;
import org.rubypeople.rdt.internal.debug.core.SuspensionPoint;
import org.rubypeople.rdt.internal.debug.core.model.RubyProcessingException;
import org.rubypeople.rdt.internal.debug.core.model.RubyStackFrame;
import org.rubypeople.rdt.internal.debug.core.model.RubyThread;
import org.rubypeople.rdt.internal.debug.core.model.RubyVariable;
[...1001 lines suppressed...]
		runToLine(4);
		// now a is calculated and the result is 4. That means that ruby does not change the code which 
	    // currently being executed in a stack frame, Java would have reset the instruction pointer and the
		// result would be 8
		sendRuby("v local") ;
		localVariables = getVariableReader().readVariables(createStackFrame());
		assertEquals("4", localVariables[0].getValue().getValueString());

		// Now check that the new code is executed with the next call to calc
		runToLine(3) ;
		runToLine(4) ;
		sendRuby("v local") ;
		localVariables = getVariableReader().readVariables(createStackFrame());
		assertEquals("8", localVariables[0].getValue().getValueString());
	}

}

--- TS_Debug.java DELETED ---

--- TC_ReadStrategyTest.java DELETED ---

--- NEW FILE: FTC_DebuggerProxyTest.java ---
package org.rubypeople.rdt.debug.core.tests;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.PrintWriter;

import junit.framework.TestCase;

import org.eclipse.core.runtime.CoreException;
import org.rubypeople.rdt.internal.debug.core.RubyDebuggerProxy;
import org.rubypeople.rdt.internal.debug.core.RubyExceptionBreakpoint;
import org.rubypeople.rdt.internal.debug.core.model.ThreadInfo;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserFactory;

public class FTC_DebuggerProxyTest extends TestCase {
	private PrintWriter writer ;
	private RubyDebuggerProxy proxy ;
	private TestRubyDebugTarget target ;
	private BufferedReader proxyOutputReader ;

	public FTC_DebuggerProxyTest(String name) {
		super(name);
	}

	protected PrintWriter getPrintWriter() {
		return writer ;
	}	

	public RubyDebuggerProxy getProxy() {
		return proxy;
	}

	public TestRubyDebugTarget getTarget() {
		return target;
	}

	public void writeToDebuggerProxy(String text) throws Exception {
		getPrintWriter().println(text) ;
		getPrintWriter().flush() ;
	}

	public String getLineFromDebuggerProxy() throws IOException {

		return proxyOutputReader.readLine() ;
	}

	public void setUp() throws Exception {
		target = new TestRubyDebugTarget() ;
		proxy = new RubyDebuggerProxy(target) ;
		PipedInputStream pipedInputStream = new PipedInputStream() ;
		PipedOutputStream pipedOutputStream = new PipedOutputStream(pipedInputStream) ; 

		proxy.setWriter(new PrintWriter(pipedOutputStream)) ;
		XmlPullParserFactory factory = XmlPullParserFactory.newInstance("org.kxml2.io.KXmlParser,org.kxml2.io.KXmlSerializer", null);
		XmlPullParser xpp = factory.newPullParser();
		PipedOutputStream outputStream = new PipedOutputStream() ;
		PipedInputStream inputStream = new PipedInputStream(outputStream) ;
		xpp.setInput(new InputStreamReader(inputStream)) ;
		proxy.setXpp(xpp) ;
		proxy.startRubyLoop() ;
		writer = new PrintWriter(new OutputStreamWriter(outputStream)) ;
		proxyOutputReader = new BufferedReader(new InputStreamReader(pipedInputStream)) ;
	}

	public void testMultipleBreakpoints() throws Exception  {
		writeToDebuggerProxy("<breakpoint file=\"\" line=\"44\" threadId=\"2\"/>") ;
		Thread.sleep(2000) ;
		assertNotNull(getTarget().getLastSuspensionPoint()) ;
		assertEquals(44, getTarget().getLastSuspensionPoint().getLine()) ;
		new Thread() {
			public void run() {
				try {
				Thread.sleep(2000) ;
				writeToDebuggerProxy("<breakpoint file=\"\" line=\"55\" threadId=\"2\"/>") ;
				writeToDebuggerProxy("<threads><thread id=\"1\" status=\"sleep\"/></threads>") ;
				} catch (Exception ex) {
					fail() ;	
				}
			}
		}.start() ;

		// blocks until threads are read
		ThreadInfo[] threadInfos = getProxy().readThreads() ;		
		assertEquals(1, threadInfos.length) ;
		Thread.sleep(1000) ;
		assertEquals(55, getTarget().getLastSuspensionPoint().getLine()) ;
	}

	public void testExceptionBreakpoint() throws IOException, CoreException {
		RubyExceptionBreakpoint rubyExceptionBreakpoint = new RubyExceptionBreakpoint("MyStandardError") ;
		proxy.addBreakpoint( rubyExceptionBreakpoint ) ;
		proxy.getWriter().flush() ;
		assertEquals("cont", this.getLineFromDebuggerProxy()) ;
		assertEquals("catch MyStandardError", this.getLineFromDebuggerProxy()) ;
	}
}