Changeset 1164

Show
Ignore:
Timestamp:
05/14/08 06:18:23 (2 months ago)
Author:
fraserofthenight
Message:

Added support to disable stack tracing in flute (since it makes Ddbg segfault).

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/descent.unittest/flute/src/org/dsource/descent/flute/flute.d

    r1162 r1164  
    308308    import std.c.stdlib: exit, EXIT_SUCCESS, EXIT_FAILURE; 
    309309    import std.c.string : strlen; 
    310     import std.string : atoi, format, find, trim = strip; 
     310    import std.string : atoi, format, trim = strip; 
    311311    import std.ctype : isdigit; 
    312312    import std.asserterror : AssertError; 
     
    347347/// A string containing version information, printed at the start of the application 
    348348private 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 */ 
     354private const string STACKTRACE_ATTR = "stacktrace"; 
    349355 
    350356/* 
     
    921927private void fluteMain() 
    922928{ 
    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 
    925941    io.write(VERSION_STRING ~ "\r\n"); 
     942     
     943    // Initialize the test registry (find all the tests) 
    926944    initRegistry(); 
     945     
     946    // Go into the main loop 
    927947    if(!commandLoop()) 
    928948        fluteExit(); 
  • trunk/descent.unittest/flute/src/org/dsource/descent/flute/io.d

    r1162 r1164  
    55 * provide socket I/O. 
    66 *  
    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. 
    139 */ 
    1410module org.dsource.descent.flute.io; 
     
    2016else 
    2117{ 
     18    public import std.string : find; 
     19     
     20    import std.c.stdlib : exit, EXIT_SUCCESS, EXIT_FAILURE; 
     21    import std.file : exists, read; 
     22 
    2223    version(FluteCommandLine) 
    2324    { 
     
    2627    else 
    2728    { 
    28         import std.c.stdlib : exit, EXIT_SUCCESS, EXIT_FAILURE; 
    2929        import std.ctype : isdigit; 
    30         import std.file : exists, read; 
    3130        import std.socket : Socket, TcpSocket, AddressFamily, InternetAddress, 
    3231            SocketShutdown, SocketException; 
     
    4342 * socket on the same port more than once will obviously not work too well). 
    4443 */ 
    45 public IOProvider getIOProvider() 
    46 
    47     return new IOProviderImpl(); 
    48 
     44public 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() 
    4967 
    5068/** 
     
    7795} 
    7896 
     97private const string CONFIG_FILE_NAME = ".fluteconfig"; 
     98private const string PORT_ATTR = "port"; 
     99 
    79100version(Tango) 
    80101{ 
     
    83104else 
    84105{ 
     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     
    85118    version(FluteCommandLine) 
    86119    { 
    87120        private final class IOProviderImpl : IOProvider 
    88         {    
     121        { 
     122            private this(string[string] config) 
     123            { 
     124                // Nothing to do 
     125            } 
     126             
    89127            public void write(string str) 
    90128            { 
     
    110148            Stream stream; 
    111149             
    112             public this(
     150            public this(string[string] config
    113151            {    
    114152                try 
    115153                { 
     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                     
    116162                    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)); 
    118164                    serv.listen(0); 
    119165                    Socket conn = serv.accept(); 
     
    156202                return stream.readLine(); 
    157203            } 
    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 */ 
     215private 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  
    2222     */ 
    2323    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$ 
    2457} 
  • trunk/descent.unittest/src/descent/internal/unittest/launcher/UnittestLaunchConfiguration.java

    r1162 r1164  
    2727import org.eclipse.debug.core.ILaunch; 
    2828import org.eclipse.debug.core.ILaunchConfiguration; 
     29import org.eclipse.debug.core.ILaunchManager; 
    2930 
    3031import descent.core.IJavaElement; 
     
    5758     * stack frame and trying to read the arguments like that). 
    5859     */ 
    59     public static final String PORT_FILENAME = ".fluteport"; //$NON-NLS-1$ 
     60    public static final String CONFIG_FILENAME = ".fluteconfig"; //$NON-NLS-1$ 
    6061     
    6162    @Override 
    6263    public void launch(ILaunchConfiguration config, String mode, 
    6364            ILaunch launch, IProgressMonitor monitor) throws CoreException 
    64     { 
    65         System.out.println(launch.getClass()); 
    66          
     65    {    
    6766        if (monitor == null) 
    6867            monitor = new NullProgressMonitor(); 
     
    8281            if(monitor.isCanceled()) 
    8382                return; 
    84              
     83             
    8584            // 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); 
    9092            if(monitor.isCanceled()) 
    9193                return; 
    92              
    93             // Create the file with the port 
    94             String portFilePath = getPortFilePath(config); 
    95             File portFile = createFile(portFilePath); 
    96             writeToFile(Integer.toString(port), portFile); 
    9794            monitor.worked(15); // 55 
    9895             
     
    165162    } 
    166163     
     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     
    167191    private static int getPort(String portStr) throws CoreException 
    168192    { 
     
    174198        catch(NumberFormatException e) { } 
    175199         
    176         if(port < 1024 || port > 65535) 
     200        if(port <= 0 || port > 65535) 
    177201            port = findFreePort(); 
    178202         
     
    204228    } 
    205229     
     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     
    206248    private static File createFile(String path) throws CoreException 
    207249    { 
     
    239281        } 
    240282    } 
    241      
    242     private String getPortFilePath(ILaunchConfiguration config) throws CoreException 
    243     { 
    244         File dirFile = verifyWorkingDirectory(config); 
    245         String dirPath; 
    246         if(null != dirFile) 
    247         { 
    248             dirPath = dirFile.getPath(); 
    249         } 
    250         else 
    251         { 
    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     } 
    259283 
    260284    @Override 
  • trunk/descent.unittest/src/descent/internal/unittest/launcher/UnittestLaunchConfigurationTab.java

    r1162 r1164  
    7575        createTestSelection(comp); 
    7676        createPortSelection(comp); 
     77        createTraceSelection(comp); 
    7778 
    7879        Dialog.applyDialogFont(comp); 
     
    409410        } 
    410411         
    411         if(portNum < 1024 || portNum > 65535) 
     412        if(portNum <= 0 || portNum > 65535) 
    412413        { 
    413414            return JUnitMessages.UnittestLaunchConfigurationTab_error_port_number; 
     
    416417        return null; 
    417418    } 
    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     
    419537    //-------------------------------------------------------------------------- 
    420538    // Initialization 
     
    424542        updateTestContainerFromConfig(config); 
    425543        updatePortFromConfig(config); 
     544        updateTraceFromConfig(config); 
    426545    } 
    427546 
     
    475594        config.setAttribute(IUnittestLaunchConfigurationAttributes.INCLUDE_SUBPACKAGES_ATTR, 
    476595                fIncludeSubpackagesCheckbox.getSelection() ? "true" : "false"); //$NON-NLS-1$ //$NON-NLS-2$ 
    477          
     596        config.setAttribute(IUnittestLaunchConfigurationAttributes.ENABLE_STACKTACING_ATTR, getTraceSetting()); 
     597         
    478598        // TODO get the fluted program executable 
    479599        config.setAttribute(IDescentLaunchConfigurationConstants.ATTR_PROGRAM_NAME, 
     
    498618        config.setAttribute(IDescentLaunchConfigurationConstants.ATTR_PROJECT_NAME, project); 
    499619        config.setAttribute(IUnittestLaunchConfigurationAttributes.PORT_ATTR, ""); //$NON-NLS-1$ 
     620        config.setAttribute(IUnittestLaunchConfigurationAttributes.ENABLE_STACKTACING_ATTR, IUnittestLaunchConfigurationAttributes.STACKTRACING_DISABLED_IN_DEBUG_MODE); 
    500621    } 
    501622 
  • trunk/descent.unittest/src/descent/internal/unittest/model/TestRunSession.java

    r1162 r1164  
    130130                    if(fTestRunnerClient.isConnected()) 
    131131                        fTestRunnerClient.run(); 
     132                    fTestRunnerClient.terminate(); 
    132133                } 
    133134            } 
  • trunk/descent.unittest/src/descent/internal/unittest/ui/JUnitMessages.java

    r1162 r1164  
    107107    public static String UnittestLaunchConfigurationTab_label_test_container_selection; 
    108108    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; 
    109114    public static String UnittestLaunchConfigurationTab_tab_label; 
    110115     
  • trunk/descent.unittest/src/descent/internal/unittest/ui/JUnitMessages.properties

    r1162 r1164  
    6767UnittestLaunchConfigurationTab_label_test_container=Test container: 
    6868UnittestLaunchConfigurationTab_label_include_subpackages=Include subpackages if a package is selected 
     69UnittestLaunchConfigurationTab_stacktrace_always_enabled=Enable stack tracing 
     70UnittestLaunchConfigurationTab_stacktrace_always_disabled=Always disable stack tracing 
    6971UnittestLaunchConfigurationTab_default_package=(default package) 
     72UnittestLaunchConfigurationTab_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. 
    7073UnittestLaunchConfigurationTab_label_test_container_selection=Select a project, package, or module from which all unit tests will be run 
     74UnittestLaunchConfigurationTab_stacktrace_disabled_in_debug=Disable stack tracing in debug mode only 
    7175UnittestLaunchConfigurationTab_label_automatically_choose_port=Automatically select an available port 
    7276UnittestLaunchConfigurationTab_label_use_specified_port=Use the specified port 
     
    8488UnittestLaunchConfigurationTab_error_test_container_does_not_exist=Test container does not exist 
    8589UnittestLaunchConfigurationTab_error_invalid_port=Invalid port number 
     90UnittestLaunchConfigurationTab_stack_tacing_group=Stack tracing 
    8691UnittestLaunchConfiguration_program_does_not_exist=Program file does not exist 
    87 UnittestLaunchConfigurationTab_error_port_number=Port must be between 1024 and 65535 
     92UnittestLaunchConfigurationTab_error_port_number=Port must be between 1 and 65535 
    8893UnittestLaunchConfigurationTab_tab_label=Test 
    8994UnittestLaunchConfigurationTab_group_port=Port for test runner