Changeset 1164
- Timestamp:
- 05/14/08 06:18:23 (2 months ago)
- Files:
-
- trunk/descent.unittest/flute/src/org/dsource/descent/flute/flute.d (modified) (3 diffs)
- trunk/descent.unittest/flute/src/org/dsource/descent/flute/io.d (modified) (8 diffs)
- trunk/descent.unittest/src/descent/internal/unittest/launcher/IUnittestLaunchConfigurationAttributes.java (modified) (1 diff)
- trunk/descent.unittest/src/descent/internal/unittest/launcher/UnittestLaunchConfiguration.java (modified) (7 diffs)
- trunk/descent.unittest/src/descent/internal/unittest/launcher/UnittestLaunchConfigurationTab.java (modified) (6 diffs)
- trunk/descent.unittest/src/descent/internal/unittest/model/TestRunSession.java (modified) (1 diff)
- trunk/descent.unittest/src/descent/internal/unittest/ui/JUnitMessages.java (modified) (1 diff)
- trunk/descent.unittest/src/descent/internal/unittest/ui/JUnitMessages.properties (modified) (2 diffs)
Legend:
- Unmodified
- Added
- Removed
- Modified
- Copied
- Moved
trunk/descent.unittest/flute/src/org/dsource/descent/flute/flute.d
r1162 r1164 308 308 import std.c.stdlib: exit, EXIT_SUCCESS, EXIT_FAILURE; 309 309 import std.c.string : strlen; 310 import std.string : atoi, format, find,trim = strip;310 import std.string : atoi, format, trim = strip; 311 311 import std.ctype : isdigit; 312 312 import std.asserterror : AssertError; … … 347 347 /// A string containing version information, printed at the start of the application 348 348 private const char[] VERSION_STRING = "flute 0.1"; 349 350 /** 351 * The config attribute representing whether stacktraces should be used, either 352 * "on" or "off" 353 */ 354 private const string STACKTRACE_ATTR = "stacktrace"; 349 355 350 356 /* … … 921 927 private void fluteMain() 922 928 { 923 TracedException.traceAllExceptions(); 924 io = getIOProvider(); 929 // Read the config file 930 string[string] config = readConfig(); 931 932 // Get the I/O provider 933 io = getIOProvider(config); 934 935 // Activate stack tracing if needed 936 string* enableStackTrace = STACKTRACE_ATTR in config; 937 if(enableStackTrace && (*enableStackTrace) == "on") 938 TracedException.traceAllExceptions(true); 939 940 // Write out the evrsion info 925 941 io.write(VERSION_STRING ~ "\r\n"); 942 943 // Initialize the test registry (find all the tests) 926 944 initRegistry(); 945 946 // Go into the main loop 927 947 if(!commandLoop()) 928 948 fluteExit(); trunk/descent.unittest/flute/src/org/dsource/descent/flute/io.d
r1162 r1164 5 5 * provide socket I/O. 6 6 * 7 * The socket will always bind to the localhost, and will open a port determined 8 * by the contents of the ".fluteport" file (without the quotes) in the current 9 * working directory. This file's sole contents should be an ASCII-encoded 10 * decimal integer between 1024 and 65535m representing the port flute should 11 * open on. If this file does not exist or is in the wrong format, an error will 12 * be printed to stdout and the application will exit. 7 * Also provides the means for getting the configuration file and exports a 8 * library-independent "find" function. 13 9 */ 14 10 module org.dsource.descent.flute.io; … … 20 16 else 21 17 { 18 public import std.string : find; 19 20 import std.c.stdlib : exit, EXIT_SUCCESS, EXIT_FAILURE; 21 import std.file : exists, read; 22 22 23 version(FluteCommandLine) 23 24 { … … 26 27 else 27 28 { 28 import std.c.stdlib : exit, EXIT_SUCCESS, EXIT_FAILURE;29 29 import std.ctype : isdigit; 30 import std.file : exists, read;31 30 import std.socket : Socket, TcpSocket, AddressFamily, InternetAddress, 32 31 SocketShutdown, SocketException; … … 43 42 * socket on the same port more than once will obviously not work too well). 44 43 */ 45 public IOProvider getIOProvider() 46 { 47 return new IOProviderImpl(); 48 } 44 public IOProvider getIOProvider(string[string] config) 45 { 46 return new IOProviderImpl(config); 47 } 48 49 /** 50 * Finds needle in the hasytack or returns -1 on failure (Tango's find returns 51 * the length of the string while Phobos's returns -1. The function exported 52 * from this module acts as Phobos's). 53 */ 54 // uint find(string haystack, string needle) 55 56 /** 57 * Reads the configuaration file. The file should be a file in the working 58 * diretcory called ".fluteconfig" and have a set of keys and values on the 59 * same line separated by an =, with newlines separating the pairs, like so: 60 * 61 * port=30587 62 * stacktrace=on 63 * 64 * There must be a newline after the last pair. 65 */ 66 // string[string] readConfig() 49 67 50 68 /** … … 77 95 } 78 96 97 private const string CONFIG_FILE_NAME = ".fluteconfig"; 98 private const string PORT_ATTR = "port"; 99 79 100 version(Tango) 80 101 { … … 83 104 else 84 105 { 106 string[string] readConfig() 107 { 108 if(!exists(CONFIG_FILE_NAME)) 109 { 110 writef("Couldn't open config file %s\n", CONFIG_FILE_NAME); 111 exit(EXIT_FAILURE); 112 } 113 114 string contents = cast(string) read(CONFIG_FILE_NAME); 115 return parseConfigFile(contents); 116 } 117 85 118 version(FluteCommandLine) 86 119 { 87 120 private final class IOProviderImpl : IOProvider 88 { 121 { 122 private this(string[string] config) 123 { 124 // Nothing to do 125 } 126 89 127 public void write(string str) 90 128 { … … 110 148 Stream stream; 111 149 112 public this( )150 public this(string[string] config) 113 151 { 114 152 try 115 153 { 154 string* portStr = PORT_ATTR in config; 155 if(!portStr) 156 { 157 writef("No port defined in config file\n"); 158 exit(EXIT_FAILURE); 159 } 160 uint port = atoi(*portStr); 161 116 162 serv = new TcpSocket(AddressFamily.INET); 117 serv.bind(new InternetAddress("127.0.0.1", getPort()));163 serv.bind(new InternetAddress("127.0.0.1", port)); 118 164 serv.listen(0); 119 165 Socket conn = serv.accept(); … … 156 202 return stream.readLine(); 157 203 } 158 159 private const string CONFIG_FILE_NAME = ".fluteport"; 160 161 private uint getPort() 162 { 163 if(!exists(CONFIG_FILE_NAME)) 164 { 165 writef("Couldn't open config file %s\n", CONFIG_FILE_NAME); 166 exit(EXIT_FAILURE); 167 } 168 169 string contents = cast(string) read(CONFIG_FILE_NAME); 170 171 uint i = 0; 172 while(i < contents.length && isdigit(contents[i])) 173 i++; 174 175 if(0 == i) 176 { 177 writef("Invalid flute config file %s\n", CONFIG_FILE_NAME); 178 exit(EXIT_FAILURE); 179 } 180 181 string portStr = contents[0 .. i]; 182 int portNum = atoi(portStr); 183 184 if(portNum < 1024 || portNum > 65535) 185 { 186 writef("Invalid port %d - Must be in the range 1024 .. 65535\n", 187 portNum); 188 exit(EXIT_FAILURE); 189 } 190 191 return portNum; 192 } 193 } 194 } 195 } 204 } 205 } 206 } 207 208 /** 209 * Process the contents of the config file. 210 * 211 * Params: 212 * content = the contents of the config file 213 * Returns: the configuration data as a string -> string hash 214 */ 215 private string[string] parseConfigFile(string content) 216 { 217 // This function splits the line and adds it to the config 218 string[string] config; 219 void processLine(string line) 220 { 221 int pos = find(line, '='); 222 if(pos <= 0 || pos + 1 == line.length) 223 return; 224 225 string key = line[0 .. pos]; 226 string value = line[pos + 1 .. $]; 227 config[key]= value; 228 } 229 230 // Enumerate through the lines, passing them to processLine 231 uint start = 0; 232 foreach (i, c; content) 233 { 234 if (c == '\n') 235 { 236 uint end = i; 237 if(end && (content[end - 1] == '\r')) 238 --end; 239 processLine(content[start .. end]); 240 start = i + 1; 241 } 242 } 243 244 return config; 245 } trunk/descent.unittest/src/descent/internal/unittest/launcher/IUnittestLaunchConfigurationAttributes.java
r1112 r1164 22 22 */ 23 23 public static final String INCLUDE_SUBPACKAGES_ATTR= DescentUnittestPlugin.PLUGIN_ID+".INCLUDE_SUBPACKAGES"; //$NON-NLS-1$ 24 25 /** 26 * If this attribute is defined, it sets whether stack tracing should be enabled 27 * in the fluted executable. It must be one of: 28 * 29 * {@link #STACKTRACING_ENABLED} - Stack tracing is enabled 30 * {@link #STACKTRACING_DISABLED_IN_DEBUG_MODE} - Stack tracing is disabled 31 * if this launch configuration is launched in debug mode 32 * {@link #STACKTRACING_DISABLED} - Stack tracing is disabled 33 */ 34 public static final String ENABLE_STACKTACING_ATTR= DescentUnittestPlugin.PLUGIN_ID+".ENABLE_STACKTRACING"; //$NON-NLS-1$ 35 36 /** 37 * Constant used for {@link #ENABLE_STACKTACING_ATTR}. Stack tracing is enabled. 38 * 39 * @see #ENABLE_STACKTACING_ATTR 40 */ 41 public static final String STACKTRACING_ENABLED= "enabled"; //$NON-NLS-1$ 42 43 /** 44 * Constant used for {@link #ENABLE_STACKTACING_ATTR}. Stack tracing is enabled 45 * except in debug mode. 46 * 47 * @see #ENABLE_STACKTACING_ATTR 48 */ 49 public static final String STACKTRACING_DISABLED_IN_DEBUG_MODE= "disabled_in_debug_mode"; //$NON-NLS-1$ 50 51 /** 52 * Constant used for {@link #ENABLE_STACKTACING_ATTR}. Stack tracing is disabled. 53 * 54 * @see #ENABLE_STACKTACING_ATTR 55 */ 56 public static final String STACKTRACING_DISABLED= "disabled"; //$NON-NLS-1$ 24 57 } trunk/descent.unittest/src/descent/internal/unittest/launcher/UnittestLaunchConfiguration.java
r1162 r1164 27 27 import org.eclipse.debug.core.ILaunch; 28 28 import org.eclipse.debug.core.ILaunchConfiguration; 29 import org.eclipse.debug.core.ILaunchManager; 29 30 30 31 import descent.core.IJavaElement; … … 57 58 * stack frame and trying to read the arguments like that). 58 59 */ 59 public static final String PORT_FILENAME = ".fluteport"; //$NON-NLS-1$60 public static final String CONFIG_FILENAME = ".fluteconfig"; //$NON-NLS-1$ 60 61 61 62 @Override 62 63 public void launch(ILaunchConfiguration config, String mode, 63 64 ILaunch launch, IProgressMonitor monitor) throws CoreException 64 { 65 System.out.println(launch.getClass()); 66 65 { 67 66 if (monitor == null) 68 67 monitor = new NullProgressMonitor(); … … 82 81 if(monitor.isCanceled()) 83 82 return; 84 83 85 84 // Get the port 86 String portStr = config.getAttribute(IUnittestLaunchConfigurationAttributes.PORT_ATTR, ""); //$NON-NLS-1$ 87 int port = getPort(portStr); 88 if(port < 1024 || port > 65535) 89 throw error(JUnitMessages.UnittestLaunchConfiguration_invalid_port); 85 String portStr = config.getAttribute(IUnittestLaunchConfigurationAttributes.PORT_ATTR, ""); //$NON-NLS-1$ 86 int port = getPort(portStr); 87 if(port <= 0 || port > 65535) 88 throw error(JUnitMessages.UnittestLaunchConfiguration_invalid_port); 89 90 // Create the config file 91 createConfigFile(config, mode, port); 90 92 if(monitor.isCanceled()) 91 93 return; 92 93 // Create the file with the port94 String portFilePath = getPortFilePath(config);95 File portFile = createFile(portFilePath);96 writeToFile(Integer.toString(port), portFile);97 94 monitor.worked(15); // 55 98 95 … … 165 162 } 166 163 164 private void createConfigFile(ILaunchConfiguration config, String mode, 165 int port) throws CoreException 166 { 167 // Get whether stack tracing is enabled 168 boolean stackTrace; 169 String stackTraceStr = config.getAttribute(IUnittestLaunchConfigurationAttributes.ENABLE_STACKTACING_ATTR, 170 IUnittestLaunchConfigurationAttributes.STACKTRACING_DISABLED_IN_DEBUG_MODE); 171 if(IUnittestLaunchConfigurationAttributes.STACKTRACING_ENABLED.equals(stackTraceStr)) 172 stackTrace = true; 173 else if(IUnittestLaunchConfigurationAttributes.STACKTRACING_DISABLED.equals(stackTraceStr)) 174 stackTrace = false; 175 else 176 stackTrace = !mode.equals(ILaunchManager.DEBUG_MODE); 177 178 // Generate the string which should be written to the file 179 StringBuilder contents = new StringBuilder(); 180 contents.append("port="); //$NON-NLS-1$ 181 contents.append(Integer.toString(port)); 182 contents.append("\nstacktrace="); //$NON-NLS-1$ 183 contents.append(stackTrace ? "on\n" : "off\n"); //$NON-NLS-1$ //$NON-NLS-2$ 184 185 // Generate and write the file 186 String configFilePath = getConfigFilePath(config); 187 File configFile = createFile(configFilePath); 188 writeToFile(contents.toString(), configFile); 189 } 190 167 191 private static int getPort(String portStr) throws CoreException 168 192 { … … 174 198 catch(NumberFormatException e) { } 175 199 176 if(port < 1024|| port > 65535)200 if(port <= 0 || port > 65535) 177 201 port = findFreePort(); 178 202 … … 204 228 } 205 229 230 private String getConfigFilePath(ILaunchConfiguration config) throws CoreException 231 { 232 File dirFile = verifyWorkingDirectory(config); 233 String dirPath; 234 if(null != dirFile) 235 { 236 dirPath = dirFile.getPath(); 237 } 238 else 239 { 240 File exe = new File(verifyProgramPath(config).toOSString()); 241 if(!exe.exists() || !exe.isFile()) 242 throw error(JUnitMessages.UnittestLaunchConfiguration_program_does_not_exist); 243 dirPath = exe.getParent(); 244 } 245 return dirPath + File.separator + CONFIG_FILENAME; 246 } 247 206 248 private static File createFile(String path) throws CoreException 207 249 { … … 239 281 } 240 282 } 241 242 private String getPortFilePath(ILaunchConfiguration config) throws CoreException243 {244 File dirFile = verifyWorkingDirectory(config);245 String dirPath;246 if(null != dirFile)247 {248 dirPath = dirFile.getPath();249 }250 else251 {252 File exe = new File(verifyProgramPath(config).toOSString());253 if(!exe.exists() || !exe.isFile())254 throw error(JUnitMessages.UnittestLaunchConfiguration_program_does_not_exist);255 dirPath = exe.getParent();256 }257 return dirPath + File.separator + PORT_FILENAME;258 }259 283 260 284 @Override trunk/descent.unittest/src/descent/internal/unittest/launcher/UnittestLaunchConfigurationTab.java
r1162 r1164 75 75 createTestSelection(comp); 76 76 createPortSelection(comp); 77 createTraceSelection(comp); 77 78 78 79 Dialog.applyDialogFont(comp); … … 409 410 } 410 411 411 if(portNum < 1024|| portNum > 65535)412 if(portNum <= 0 || portNum > 65535) 412 413 { 413 414 return JUnitMessages.UnittestLaunchConfigurationTab_error_port_number; … … 416 417 return null; 417 418 } 418 419 420 //-------------------------------------------------------------------------- 421 // Trace selection 422 423 private Group fTraceGroup; 424 private Label fTraceInfo; 425 private Button fAlwaysRadioButton; 426 private Button fNoDebugModeRadioButton; 427 private Button fNeverRadioButton; 428 429 private void createTraceSelection(Composite comp) 430 { 431 fTraceGroup = createGroup(comp, JUnitMessages.UnittestLaunchConfigurationTab_stack_tacing_group); 432 433 fTraceInfo = new Label(fTraceGroup, SWT.LEFT | SWT.WRAP); 434 fTraceInfo.setText(JUnitMessages.UnittestLaunchConfigurationTab_stacktrace_info); 435 GridData gd = new GridData(GridData.FILL_BOTH); 436 gd.horizontalSpan = 3; 437 fTraceInfo.setLayoutData(gd); 438 439 Label spacer = new Label(fTraceGroup, SWT.NONE); 440 gd = new GridData(); 441 gd.horizontalAlignment= GridData.BEGINNING; 442 gd.grabExcessHorizontalSpace = false; 443 gd.horizontalSpan = 3; 444 gd.horizontalIndent = 0; 445 gd.widthHint = 0; 446 gd.heightHint = 0; 447 spacer.setLayoutData(gd); 448 449 fAlwaysRadioButton = new Button(fTraceGroup, SWT.RADIO); 450 fAlwaysRadioButton.setText(JUnitMessages.UnittestLaunchConfigurationTab_stacktrace_always_enabled); 451 gd = new GridData(); 452 gd.horizontalSpan = 3; 453 gd.horizontalIndent = 25; 454 fAlwaysRadioButton.setLayoutData(gd); 455 fAlwaysRadioButton.addSelectionListener(new SelectionAdapter() 456 { 457 public void widgetSelected(SelectionEvent e) 458 { 459 if(fAlwaysRadioButton.getSelection()) 460 updateLaunchConfigurationDialog(); 461 } 462 }); 463 464 fNoDebugModeRadioButton = new Button(fTraceGroup, SWT.RADIO); 465 fNoDebugModeRadioButton.setText(JUnitMessages.UnittestLaunchConfigurationTab_stacktrace_disabled_in_debug); 466 gd = new GridData(); 467 gd.horizontalSpan = 3; 468 gd.horizontalIndent = 25; 469 fNoDebugModeRadioButton.setLayoutData(gd); 470 fNoDebugModeRadioButton.addSelectionListener(new SelectionAdapter() 471 { 472 public void widgetSelected(SelectionEvent e) 473 { 474 if(fNoDebugModeRadioButton.getSelection()) 475 updateLaunchConfigurationDialog(); 476 } 477 }); 478 479 fNeverRadioButton = new Button(fTraceGroup, SWT.RADIO); 480 fNeverRadioButton.setText(JUnitMessages.UnittestLaunchConfigurationTab_stacktrace_always_disabled); 481 gd = new GridData(); 482 gd.horizontalSpan = 3; 483 gd.horizontalIndent = 25; 484 fNeverRadioButton.setLayoutData(gd); 485 fNeverRadioButton.addSelectionListener(new SelectionAdapter() 486 { 487 public void widgetSelected(SelectionEvent e) 488 { 489 if(fNeverRadioButton.getSelection()) 490 updateLaunchConfigurationDialog(); 491 } 492 }); 493 } 494 495 private void updateTraceFromConfig(ILaunchConfiguration config) 496 { 497 String stackTraceMode = IUnittestLaunchConfigurationAttributes.STACKTRACING_DISABLED_IN_DEBUG_MODE; 498 try 499 { 500 stackTraceMode = config.getAttribute(IUnittestLaunchConfigurationAttributes.ENABLE_STACKTACING_ATTR, 501 IUnittestLaunchConfigurationAttributes.STACKTRACING_DISABLED_IN_DEBUG_MODE); 502 } 503 catch(CoreException ce) { } 504 505 if(stackTraceMode.equals(IUnittestLaunchConfigurationAttributes.STACKTRACING_ENABLED)) 506 { 507 fAlwaysRadioButton.setSelection(true); 508 fNoDebugModeRadioButton.setSelection(false); 509 fNeverRadioButton.setSelection(false); 510 } 511 else if(stackTraceMode.equals(IUnittestLaunchConfigurationAttributes.STACKTRACING_DISABLED)) 512 { 513 fAlwaysRadioButton.setSelection(false); 514 fNoDebugModeRadioButton.setSelection(false); 515 fNeverRadioButton.setSelection(true); 516 } 517 else 518 { 519 fAlwaysRadioButton.setSelection(false); 520 fNoDebugModeRadioButton.setSelection(true); 521 fNeverRadioButton.setSelection(false); 522 } 523 } 524 525 private String getTraceSetting() 526 { 527 if(fAlwaysRadioButton.getSelection()) 528 return IUnittestLaunchConfigurationAttributes.STACKTRACING_ENABLED; 529 else if(fNoDebugModeRadioButton.getSelection()) 530 return IUnittestLaunchConfigurationAttributes.STACKTRACING_DISABLED_IN_DEBUG_MODE; 531 else if(fNeverRadioButton.getSelection()) 532 return IUnittestLaunchConfigurationAttributes.STACKTRACING_DISABLED; 533 else 534 return null; 535 } 536 419 537 //-------------------------------------------------------------------------- 420 538 // Initialization … … 424 542 updateTestContainerFromConfig(config); 425 543 updatePortFromConfig(config); 544 updateTraceFromConfig(config); 426 545 } 427 546 … … 475 594 config.setAttribute(IUnittestLaunchConfigurationAttributes.INCLUDE_SUBPACKAGES_ATTR, 476 595 fIncludeSubpackagesCheckbox.getSelection() ? "true" : "false"); //$NON-NLS-1$ //$NON-NLS-2$ 477 596 config.setAttribute(IUnittestLaunchConfigurationAttributes.ENABLE_STACKTACING_ATTR, getTraceSetting()); 597 478 598 // TODO get the fluted program executable 479 599 config.setAttribute(IDescentLaunchConfigurationConstants.ATTR_PROGRAM_NAME, … … 498 618 config.setAttribute(IDescentLaunchConfigurationConstants.ATTR_PROJECT_NAME, project); 499 619 config.setAttribute(IUnittestLaunchConfigurationAttributes.PORT_ATTR, ""); //$NON-NLS-1$ 620 config.setAttribute(IUnittestLaunchConfigurationAttributes.ENABLE_STACKTACING_ATTR, IUnittestLaunchConfigurationAttributes.STACKTRACING_DISABLED_IN_DEBUG_MODE); 500 621 } 501 622 trunk/descent.unittest/src/descent/internal/unittest/model/TestRunSession.java
r1162 r1164 130 130 if(fTestRunnerClient.isConnected()) 131 131 fTestRunnerClient.run(); 132 fTestRunnerClient.terminate(); 132 133 } 133 134 } trunk/descent.unittest/src/descent/internal/unittest/ui/JUnitMessages.java
r1162 r1164 107 107 public static String UnittestLaunchConfigurationTab_label_test_container_selection; 108 108 public static String UnittestLaunchConfigurationTab_label_use_specified_port; 109 public static String UnittestLaunchConfigurationTab_stack_tacing_group; 110 public static String UnittestLaunchConfigurationTab_stacktrace_always_disabled; 111 public static String UnittestLaunchConfigurationTab_stacktrace_always_enabled; 112 public static String UnittestLaunchConfigurationTab_stacktrace_disabled_in_debug; 113 public static String UnittestLaunchConfigurationTab_stacktrace_info; 109 114 public static String UnittestLaunchConfigurationTab_tab_label; 110 115 trunk/descent.unittest/src/descent/internal/unittest/ui/JUnitMessages.properties
r1162 r1164 67 67 UnittestLaunchConfigurationTab_label_test_container=Test container: 68 68 UnittestLaunchConfigurationTab_label_include_subpackages=Include subpackages if a package is selected 69 UnittestLaunchConfigurationTab_stacktrace_always_enabled=Enable stack tracing 70 UnittestLaunchConfigurationTab_stacktrace_always_disabled=Always disable stack tracing 69 71 UnittestLaunchConfigurationTab_default_package=(default package) 72 UnittestLaunchConfigurationTab_stacktrace_info=The mechanism used to generate stack traces can cause issues when using some debuggers, flectioned, or other backtrace hacks. In particular, it causes Ddbg to segfault, so should always be turned off under Ddbg. If problems are encountered, try turning off stack tracing. 70 73 UnittestLaunchConfigurationTab_label_test_container_selection=Select a project, package, or module from which all unit tests will be run 74 UnittestLaunchConfigurationTab_stacktrace_disabled_in_debug=Disable stack tracing in debug mode only 71 75 UnittestLaunchConfigurationTab_label_automatically_choose_port=Automatically select an available port 72 76 UnittestLaunchConfigurationTab_label_use_specified_port=Use the specified port … … 84 88 UnittestLaunchConfigurationTab_error_test_container_does_not_exist=Test container does not exist 85 89 UnittestLaunchConfigurationTab_error_invalid_port=Invalid port number 90 UnittestLaunchConfigurationTab_stack_tacing_group=Stack tracing 86 91 UnittestLaunchConfiguration_program_does_not_exist=Program file does not exist 87 UnittestLaunchConfigurationTab_error_port_number=Port must be between 1 024and 6553592 UnittestLaunchConfigurationTab_error_port_number=Port must be between 1 and 65535 88 93 UnittestLaunchConfigurationTab_tab_label=Test 89 94 UnittestLaunchConfigurationTab_group_port=Port for test runner
