← Back to branch summary

~ubuntu-branches/debian/sid/eclipse-cdt/sid

« back to all changes in this revision

Viewing changes to results/plugins/org.eclipse.cdt.managedbuilder.core.tests/tests/org/eclipse/cdt/managedbuilder/core/tests/ManagedBuildMacrosTests.java

  • Committer: Package Import Robot
  • Author(s): Jakub Adam
  • Date: 2011-10-06 21:15:04 UTC
  • mfrom: (1.1.4)
  • Revision ID: package-import@ubuntu.com-20111006211504-8dutmljjih0zikfv
Tags: 8.0.1-1
* New upstream release.
* Split the JNI packages into a separate architecture dependent
  package and made eclipse-cdt architecture independent.
* Install JNI libraries into multiarch aware location
* Bumped Standards-Version to 3.9.2.

Show diffs side-by-side

added added

removed removed

Lines of Context:
results/plugins/org.eclipse.cdt.managedbuilder.core.tests/tests/org/eclipse/cdt/managedbuilder/core/tests/ManagedBuildMacrosTests.java
1
 
/*******************************************************************************
2
 
 * Copyright (c) 2005, 2007 Intel Corporation and others.
3
 
 * All rights reserved. This program and the accompanying materials
4
 
 * are made available under the terms of the Eclipse Public License v1.0
5
 
 * which accompanies this distribution, and is available at
6
 
 * http://www.eclipse.org/legal/epl-v10.html
7
 
 *
8
 
 * Contributors:
9
 
 * Intel Corporation - Initial API and implementation
10
 
 *******************************************************************************/
11
 
 
12
 
package org.eclipse.cdt.managedbuilder.core.tests;
13
 
 
14
 
import java.io.ByteArrayInputStream;
15
 
import java.util.ArrayList;
16
 
 
17
 
import junit.framework.Test;
18
 
import junit.framework.TestCase;
19
 
import junit.framework.TestSuite;
20
 
 
21
 
import org.eclipse.cdt.core.CCorePlugin;
22
 
import org.eclipse.cdt.core.ICDescriptor;
23
 
import org.eclipse.cdt.managedbuilder.core.BuildException;
24
 
import org.eclipse.cdt.managedbuilder.core.IConfiguration;
25
 
import org.eclipse.cdt.managedbuilder.core.IManagedBuildInfo;
26
 
import org.eclipse.cdt.managedbuilder.core.IManagedProject;
27
 
import org.eclipse.cdt.managedbuilder.core.IOption;
28
 
import org.eclipse.cdt.managedbuilder.core.IProjectType;
29
 
import org.eclipse.cdt.managedbuilder.core.ITool;
30
 
import org.eclipse.cdt.managedbuilder.core.IToolChain;
31
 
import org.eclipse.cdt.managedbuilder.core.ManagedBuildManager;
32
 
import org.eclipse.cdt.managedbuilder.core.ManagedBuilderCorePlugin;
33
 
import org.eclipse.cdt.managedbuilder.core.ManagedCProjectNature;
34
 
import org.eclipse.cdt.managedbuilder.internal.macros.OptionContextData;
35
 
import org.eclipse.cdt.managedbuilder.macros.BuildMacroException;
36
 
import org.eclipse.cdt.managedbuilder.macros.IBuildMacro;
37
 
import org.eclipse.cdt.managedbuilder.macros.IBuildMacroProvider;
38
 
import org.eclipse.cdt.managedbuilder.macros.IBuildMacroSupplier;
39
 
import org.eclipse.core.resources.IFile;
40
 
import org.eclipse.core.resources.IProject;
41
 
import org.eclipse.core.resources.IWorkspace;
42
 
import org.eclipse.core.resources.IWorkspaceDescription;
43
 
import org.eclipse.core.resources.IWorkspaceRoot;
44
 
import org.eclipse.core.resources.ResourcesPlugin;
45
 
import org.eclipse.core.runtime.CoreException;
46
 
import org.eclipse.core.runtime.NullProgressMonitor;
47
 
 
48
 
 
49
 
public class ManagedBuildMacrosTests extends TestCase {
50
 
        static IProject proj = null;
51
 
        static IManagedProject mproj = null;
52
 
        
53
 
        IConfiguration[] cfgs = null;
54
 
        IBuildMacroProvider mp = null;
55
 
        IWorkspace worksp = null;
56
 
        boolean windows = false;
57
 
        
58
 
        boolean print = false; // allows to print most of macros on console
59
 
        boolean flag  = false; // uplevel flag for getMacro/getMacros methods 
60
 
        IBuildMacroSupplier[] ms = null;
61
 
        public static int functionCalled = 0;
62
 
        public static final int GET_ONE_PROJECT  = 1;
63
 
        public static final int GET_MANY_PROJECT = 2;
64
 
        public static final int GET_ONE_CONFIG   = 4;
65
 
        public static final int GET_MANY_CONFIG  = 8;
66
 
        public static final int RESERVED_NAME    = 16;
67
 
        
68
 
        static final String UNKNOWN = "<HZ>"; //$NON-NLS-1$
69
 
        static final String LISTSEP = "|";    //$NON-NLS-1$
70
 
        static final String TEST = "TEST";    //$NON-NLS-1$
71
 
        static final String[] TST = {"DUMMY", "FILETEST",   //$NON-NLS-1$ //$NON-NLS-2$
72
 
                "OPTTEST", "CFGTEST", "PRJTEST",  //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
73
 
                "WSPTEST", "INSTEST", "ENVTEST"}; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
74
 
        // used for options testing
75
 
        final String OPT_IDS = "macro.test.string";  //$NON-NLS-1$
76
 
        final String OPT_IDL = "macro.test.list";    //$NON-NLS-1$
77
 
        final String INC_DEF  = "${IncludeDefaults}";//$NON-NLS-1$
78
 
        
79
 
        public ManagedBuildMacrosTests() { super(); }
80
 
        public ManagedBuildMacrosTests(String name) { super(name); }
81
 
 
82
 
        public static Test suite() {
83
 
                TestSuite suite = new TestSuite(ManagedBuildMacrosTests.class);
84
 
                //$JUnit-BEGIN$
85
 
//              suite.addTest(new ManagedBuildMacrosTests("testMacroConf"));//$NON-NLS-1$
86
 
//              suite.addTest(new ManagedBuildMacrosTests("testMacroEEnv"));//$NON-NLS-1$
87
 
//              suite.addTest(new ManagedBuildMacrosTests("testMacroInst"));//$NON-NLS-1$
88
 
//              suite.addTest(new ManagedBuildMacrosTests("testMacroProj"));//$NON-NLS-1$
89
 
//              suite.addTest(new ManagedBuildMacrosTests("testMacroWrks"));//$NON-NLS-1$
90
 
//              suite.addTest(new ManagedBuildMacrosTests("testMacroOptS"));//$NON-NLS-1$
91
 
//              suite.addTest(new ManagedBuildMacrosTests("testMacroOptL"));//$NON-NLS-1$
92
 
//              suite.addTest(new ManagedBuildMacrosTests("testMacroFile"));//$NON-NLS-1$
93
 
//              suite.addTest(new ManagedBuildMacrosTests("testMacroContext"));//$NON-NLS-1$
94
 
//              
95
 
//              suite.addTest(new ManagedBuildMacrosTests("testMacroResolve"));//$NON-NLS-1$
96
 
//              suite.addTest(new ManagedBuildMacrosTests("testMacroResolveExceptions"));//$NON-NLS-1$
97
 
//              suite.addTest(new ManagedBuildMacrosTests("testMacroResolveLoop"));//$NON-NLS-1$
98
 
//              suite.addTest(new ManagedBuildMacrosTests("testMacroResolveMake"));//$NON-NLS-1$
99
 
//              suite.addTest(new ManagedBuildMacrosTests("testMacroResolveCase"));//$NON-NLS-1$
100
 
//              suite.addTest(new ManagedBuildMacrosTests("testMacroSave"));//$NON-NLS-1$
101
 
                //$JUnit-END$
102
 
                return suite;
103
 
        }
104
 
 
105
 
        /**
106
 
         * testMacroConf()
107
 
         */
108
 
/*      public void testMacroConf(){
109
 
                doInit();
110
 
                ms = mp.getSuppliers(IBuildMacroProvider.CONTEXT_CONFIGURATION, cfgs[0]);
111
 
                assertNotNull(ms);
112
 
                assertEquals(ms.length, 4);
113
 
                assertTrue(addMacro(TEST, IBuildMacro.VALUE_TEXT, TST[IBuildMacroProvider.CONTEXT_CONFIGURATION],
114
 
                                IBuildMacroProvider.CONTEXT_CONFIGURATION, cfgs[0]));
115
 
                functionCalled = 0;
116
 
                String[] a = printMacros(mp.getMacros(IBuildMacroProvider.CONTEXT_CONFIGURATION, cfgs[0], flag), "Configuration"); //$NON-NLS-1$
117
 
                assertEquals(GET_MANY_CONFIG, functionCalled);
118
 
                String[] b = {"ConfigName", "BuildArtifactFileExt", //$NON-NLS-1$ //$NON-NLS-2$
119
 
                                "BuildArtifactFileBaseName", "TargetArchList", //$NON-NLS-1$ //$NON-NLS-2$
120
 
                                "TargetOsList", "BuildArtifactFileName", //$NON-NLS-1$ //$NON-NLS-2$
121
 
                                "PWD", "CWD", "ConfigDescription", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ 
122
 
                                TEST, "NEW_FOR_CFG" }; //$NON-NLS-1$
123
 
                assertTrue(arrayContains(b, a));
124
 
        }
125
 
*/
126
 
        /**
127
 
         * testMacroEEnv()
128
 
         */
129
 
/*      public void testMacroEEnv(){
130
 
                doInit();
131
 
                ms = mp.getSuppliers(IBuildMacroProvider.CONTEXT_ECLIPSEENV, null);
132
 
                assertNotNull(ms);
133
 
                assertEquals(ms.length, 1);
134
 
                assertFalse(addMacro(TEST, IBuildMacro.VALUE_TEXT, TST[IBuildMacroProvider.CONTEXT_ECLIPSEENV],
135
 
                                IBuildMacroProvider.CONTEXT_ECLIPSEENV, null));
136
 
                String[] a = printMacros(mp.getMacros(IBuildMacroProvider.CONTEXT_ECLIPSEENV, null, flag), "EclipseEnv"); //$NON-NLS-1$         
137
 
//              String[] b = {"PATH", "USERNAME"}; //$NON-NLS-1$ //$NON-NLS-2$
138
 
//              assertTrue(arrayContains(b, a));
139
 
        }
140
 
*/
141
 
        /**
142
 
         * testMacroInst()
143
 
         */
144
 
/*      public void testMacroInst(){
145
 
                doInit();
146
 
                ms = mp.getSuppliers(IBuildMacroProvider.CONTEXT_INSTALLATIONS, null);
147
 
                assertNotNull(ms);
148
 
                assertEquals(ms.length, 1);
149
 
                assertFalse(addMacro(TEST, IBuildMacro.VALUE_TEXT, TST[IBuildMacroProvider.CONTEXT_INSTALLATIONS],
150
 
                                IBuildMacroProvider.CONTEXT_INSTALLATIONS, null));
151
 
                String[] a = printMacros(mp.getMacros(IBuildMacroProvider.CONTEXT_INSTALLATIONS, null, flag), "Installations "); //$NON-NLS-1$
152
 
                String[] b = {"HostArchName", "MBSVersion", //$NON-NLS-1$ //$NON-NLS-2$ 
153
 
                                "EclipseVersion", "HostOsName", "CDTVersion"}; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
154
 
                assertTrue(arrayContains(b, a));
155
 
        }
156
 
*/
157
 
        /**
158
 
         * testMacroProj()
159
 
         */
160
 
//      public void testMacroProj(){
161
 
//              doInit();
162
 
//              ms = mp.getSuppliers(IBuildMacroProvider.CONTEXT_PROJECT, mproj);
163
 
//              assertNotNull(ms);
164
 
//              assertEquals(ms.length, 4);
165
 
//              assertTrue(addMacro(TEST, IBuildMacro.VALUE_TEXT, TST[IBuildMacroProvider.CONTEXT_PROJECT],
166
 
//                              IBuildMacroProvider.CONTEXT_PROJECT, mproj));
167
 
//              functionCalled = 0;
168
 
//              String[] a = printMacros(mp.getMacros(IBuildMacroProvider.CONTEXT_PROJECT, mproj, flag), "Project "); //$NON-NLS-1$
169
 
//              assertEquals(GET_MANY_PROJECT, functionCalled);
170
 
//              String[] b = {"ProjDirPath", "ProjName", //$NON-NLS-1$ //$NON-NLS-2$ 
171
 
//                              TEST, "NEW_FOR_PRJ"};          //$NON-NLS-1$
172
 
//              assertTrue(arrayContains(b, a));
173
 
//      }
174
 
        
175
 
        /**
176
 
         * testMacroWrks()
177
 
         */
178
 
//      public void testMacroWrks(){
179
 
//              doInit();
180
 
//              ms = mp.getSuppliers(IBuildMacroProvider.CONTEXT_WORKSPACE, worksp);
181
 
//              assertNotNull(ms);
182
 
//              assertEquals(ms.length, 5);
183
 
//              assertTrue(addMacro(TEST, IBuildMacro.VALUE_TEXT, TST[IBuildMacroProvider.CONTEXT_WORKSPACE],
184
 
//                              IBuildMacroProvider.CONTEXT_WORKSPACE, worksp));
185
 
//              String[] a = printMacros(mp.getMacros(IBuildMacroProvider.CONTEXT_WORKSPACE, worksp, flag), "Workspace "); //$NON-NLS-1$
186
 
//              String[] b = {"DirectoryDelimiter", "WorkspaceDirPath", //$NON-NLS-1$ //$NON-NLS-2$ 
187
 
//                              "PathDelimiter", TEST};                       //$NON-NLS-1$
188
 
//              assertTrue(arrayContains(b, a));
189
 
//      }
190
 
        
191
 
        /**
192
 
         * testMacroOptn()
193
 
         */
194
 
//      public void testMacroOptS(){
195
 
//              doInit();
196
 
//              IToolChain tc = cfgs[0].getToolChain();
197
 
//              ITool       t = cfgs[0].getTools()[0];
198
 
//              IOption   opt = t.getOptionById(OPT_IDS);
199
 
//              assertNotNull(opt);
200
 
//
201
 
//              // standard check of suppliers # and attempt to add macro (should fail) 
202
 
//              ms = mp.getSuppliers(IBuildMacroProvider.CONTEXT_OPTION, new OptionContextData(opt,t));
203
 
//              assertNotNull(ms);
204
 
//              assertEquals(ms.length, 1);
205
 
//              assertFalse(addMacro(TEST, IBuildMacro.VALUE_TEXT, TST[IBuildMacroProvider.CONTEXT_OPTION], IBuildMacroProvider.CONTEXT_OPTION, new OptionContextData(opt,t)));
206
 
//
207
 
//              // modify value and check that macros is resolved 
208
 
//              try {
209
 
//                      opt = cfgs[0].setOption(t, opt, "222 " + INC_DEF);  //$NON-NLS-1$
210
 
//                      String a = mp.resolveValue(opt.getStringValue(), UNKNOWN, LISTSEP, IBuildMacroProvider.CONTEXT_OPTION, new OptionContextData(opt,t));
211
 
//                      assertEquals(a, "222 111");  //$NON-NLS-1$
212
 
//              } catch (BuildMacroException e) { fail(e.getLocalizedMessage()); }
213
 
//                catch (BuildException e) { fail(e.getLocalizedMessage()); }
214
 
//                
215
 
//              // Create resource configuration
216
 
//              IResourceConfiguration rc = cfgs[0].createResourceConfiguration(getFile());
217
 
//              assertNotNull(rc);
218
 
//              IOption ropt = rc.getTools()[0].getOptionById(OPT_IDS);
219
 
//              try {
220
 
//                      ropt = rc.setOption(rc.getTools()[0], ropt, "333 " + INC_DEF);  //$NON-NLS-1$
221
 
//                      String a = mp.resolveValue(ropt.getStringValue(), UNKNOWN, LISTSEP, IBuildMacroProvider.CONTEXT_OPTION, new OptionContextData(opt,t));
222
 
//                      assertEquals(a, "333 111");  //$NON-NLS-1$
223
 
//              } catch (Exception e) { fail(e.getLocalizedMessage());  }
224
 
//      }
225
 
        
226
 
        
227
 
        public void testMacroOptL(){
228
 
                doInit();
229
 
                IToolChain tc = cfgs[0].getToolChain();
230
 
                ITool       t = cfgs[0].getTools()[0];
231
 
                IOption   opt = t.getOptionById(OPT_IDL);
232
 
                OptionContextData ocd = new OptionContextData(opt,t);
233
 
                assertNotNull(opt);
234
 
                ms = mp.getSuppliers(IBuildMacroProvider.CONTEXT_OPTION, ocd);
235
 
                assertNotNull(ms);
236
 
                assertEquals(ms.length, 1);
237
 
                
238
 
                try {
239
 
                        String[] set0 = opt.getStringListValue();
240
 
                        assertNotNull(set0);
241
 
                        final String[] set1 = {"new a", /*"test=${TEST}",*/ INC_DEF, //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$  
242
 
                                 "${PATH}", "PRJ=${NEW_FOR_PRJ}", "LIST=" + INC_DEF};//$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
243
 
                        String[] res1 = {"new a", /*"test=CFGTEST",*/ "x", "y",      //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
244
 
                                             "z", ":", "PRJ=NewMacrosForProjectContext", "LIST=x|y|z"};        //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
245
 
                        try {
246
 
                                res1[4] = mp.resolveValue("${PATH}",UNKNOWN,LISTSEP,IBuildMacroProvider.CONTEXT_OPTION, ocd);  //$NON-NLS-1$
247
 
                        } catch (BuildMacroException e) { fail(e.getLocalizedMessage()); } 
248
 
 
249
 
                        opt = cfgs[0].setOption(t, opt, set1);
250
 
                        assertNotNull(opt);
251
 
 
252
 
                        ArrayList ar = new ArrayList(1);
253
 
                        for (int i=0; i<set1.length; i++) {
254
 
                                try {
255
 
                                        String[] aus = mp.resolveStringListValue(set1[i], UNKNOWN, LISTSEP, IBuildMacroProvider.CONTEXT_OPTION, new OptionContextData(opt,t));
256
 
                                        if (aus == null) continue;
257
 
                                        for (int j=0; j<aus.length; j++) ar.add(aus[j]);
258
 
                                } catch (BuildMacroException e) { fail(e.getLocalizedMessage()); } 
259
 
                        }
260
 
                        String[] res = (String[])ar.toArray(new String[0]);
261
 
                        assertEquals(res.length, res1.length);
262
 
                        for (int i=0; i<res.length; i++) assertEquals(res[i], res1[i]);
263
 
                } catch (BuildException e) { fail(e.getLocalizedMessage());     }
264
 
        }
265
 
        
266
 
        /**
267
 
         * testMacroFile()
268
 
         */
269
 
//      public void testMacroFile(){
270
 
//              final String EIN = "ein.c";     //$NON-NLS-1$
271
 
//              final String AUS = "aus.o";     //$NON-NLS-1$
272
 
//              final String UP2W = "..\\..\\"; //$NON-NLS-1$
273
 
//              final String UP2U = "../../";   //$NON-NLS-1$
274
 
//              final String KLMN = "\\k\\l\\m\\n\\o\\p\\";  //$NON-NLS-1$
275
 
//              final String[] names = 
276
 
//              {"InputFileName", "InputFileExt", "InputFileBaseName",   //$NON-NLS-1$ //$NON-NLS-2$  //$NON-NLS-3$
277
 
//               "InputFileRelPath", "InputDirRelPath",                  //$NON-NLS-1$ //$NON-NLS-2$ 
278
 
//               "OutputFileName", "OutputFileExt", "OutputFileBaseName",//$NON-NLS-1$ //$NON-NLS-2$  //$NON-NLS-3$  
279
 
//               "OutputFileRelPath", "OutputDirRelPath"};               //$NON-NLS-1$ //$NON-NLS-2$
280
 
//              String[] values0wAbs = 
281
 
//              {"a.f77", "f77", "a", "\\xz\\a.f77", "\\xz\\",    //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
282
 
//               "b.exe", "exe", "b", "\\tmp\\b.exe", "\\tmp\\"}; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
283
 
//              final String[] values0wRel = 
284
 
//              {EIN, "c", "ein", UP2W+EIN, UP2W,  //$NON-NLS-1$ //$NON-NLS-2$
285
 
//               AUS, "o", "aus", UP2W+AUS, UP2W}; //$NON-NLS-1$ //$NON-NLS-2$
286
 
//              
287
 
//              final String[] values0u = 
288
 
//              {EIN, "c", "ein", UP2U+EIN, UP2U,  //$NON-NLS-1$ //$NON-NLS-2$
289
 
//               AUS, "o", "aus", UP2U+AUS, UP2U}; //$NON-NLS-1$ //$NON-NLS-2$
290
 
//              
291
 
//              final String[] values1 = 
292
 
//              {"$(notdir $<)", "$(suffix $(notdir $<))",       //$NON-NLS-1$ //$NON-NLS-2$
293
 
//               "$(basename $(notdir $<))", "$<", "$(dir $<)",  //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
294
 
//               "$(notdir $@)", "$(suffix $(notdir $@))",       //$NON-NLS-1$ //$NON-NLS-2$
295
 
//               "$(basename $(notdir $@))", "$@", "$(dir $@)"}; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
296
 
//              
297
 
//              FileContextData fd = null;
298
 
//              
299
 
//              doInit();
300
 
//              ITool t = cfgs[0].getTools()[0];
301
 
//              assertNotNull(t);
302
 
//              IOption opt = t.getOptionById(OPT_IDS);
303
 
//                      
304
 
//              String dir=null;
305
 
//              try {
306
 
//                      dir = mp.getMacro("WorkspaceDirPath", IBuildMacroProvider.CONTEXT_WORKSPACE, worksp, flag).getStringValue(); //$NON-NLS-1$
307
 
//              } catch (BuildMacroException e) { fail(e.getLocalizedMessage()); }
308
 
//              IPath p = (new Path(dir)).addTrailingSeparator();
309
 
//              
310
 
//              if (windows) {
311
 
//                      // check behaviour in case of different disks usage
312
 
//                      
313
 
//                      // config #4 has changed BuilderMakeFileGenerator, #0 has standard one
314
 
//                      IBuildEnvironmentVariable cwdvar = ManagedBuildManager.getEnvironmentVariableProvider().getVariable("CWD", cfgs[0], false, true); //$NON-NLS-1$
315
 
//                      String dev0 = Path.fromOSString(cwdvar.getValue()).getDevice().toUpperCase();
316
 
//                      String dev1 = (dev0.startsWith("C")) ? "D:" : "C:";  //$NON-NLS-1$  //$NON-NLS-2$  //$NON-NLS-3$  
317
 
//                      values0wAbs[3] = dev1 + values0wAbs[3];         
318
 
//                      values0wAbs[4] = dev1 + values0wAbs[4];         
319
 
//                      values0wAbs[8] = dev1 + values0wAbs[8];
320
 
//                      values0wAbs[9] = dev1 + values0wAbs[9];
321
 
//                      
322
 
//                      fd = new FileContextData(new Path(values0wAbs[3]), new Path(values0wAbs[8]),opt,t);
323
 
//                      for (int i=0; i<names.length; i++) 
324
 
//                      try {   
325
 
//                              assertEquals(values0wAbs[i], mp.getMacro(names[i], IBuildMacroProvider.CONTEXT_FILE, fd, flag).getStringValue());
326
 
//                      } catch (BuildMacroException e) { fail(e.getLocalizedMessage()); }
327
 
//                      
328
 
//                      // check that relative path are reported OK
329
 
//                      fd = new FileContextData(p.append(EIN), p.append(AUS),opt,t);
330
 
//                      for (int i=0; i<names.length; i++) 
331
 
//                      try {
332
 
//                              assertEquals(values0wRel[i], mp.getMacro(names[i], IBuildMacroProvider.CONTEXT_FILE, fd, flag).getStringValue());
333
 
//                      } catch (BuildMacroException e) { fail(e.getLocalizedMessage()); }
334
 
//
335
 
////                    //TODO:
336
 
////                    // check paths using changed BuilderMakeFileGenerator in cfg "Five"
337
 
/////*                  
338
 
////                    int index = 4;
339
 
////                    ManagedBuildManager.setDefaultConfiguration(proj, cfgs[index]);
340
 
////                    OptionContextData op = new OptionContextData(cfgs[index].getTools()[0].getOptions()[0], cfgs[index].getToolChain());
341
 
////                    String p0 = dev0 + KLMN;
342
 
////                    fd = new FileContextData(new Path(p0+EIN), new Path(p0+AUS), op);
343
 
////                    assertNotNull(fd);
344
 
////                    //TODO: the same dir, upper dir, lower dir 
345
 
////                    try {
346
 
////                            TestMacro.topBuildDir = Path.fromOSString(p0);
347
 
////                            assertEquals(p0+EIN, mp.getMacro(names[3], IBuildMacroProvider.CONTEXT_FILE, fd, flag).getStringValue());
348
 
////                            assertEquals(p0,     mp.getMacro(names[4], IBuildMacroProvider.CONTEXT_FILE, fd, flag).getStringValue());
349
 
////                            assertEquals(p0+AUS, mp.getMacro(names[8], IBuildMacroProvider.CONTEXT_FILE, fd, flag).getStringValue());
350
 
////                            assertEquals(p0,     mp.getMacro(names[9], IBuildMacroProvider.CONTEXT_FILE, fd, flag).getStringValue());
351
 
//////                          p0 = Path.fromOSString(p0).removeLastSegments(2).addTrailingSeparator().toOSString();
352
 
//////                          p0 = dev0+KLMN+"x\\";
353
 
//////                          TestMacro.topBuildDir = Path.fromOSString(p0);
354
 
////                            assertEquals(p0+EIN, mp.getMacro(names[3], IBuildMacroProvider.CONTEXT_FILE, fd, flag).getStringValue());
355
 
////                            assertEquals(p0,     mp.getMacro(names[4], IBuildMacroProvider.CONTEXT_FILE, fd, flag).getStringValue());
356
 
////                            assertEquals(p0+AUS, mp.getMacro(names[8], IBuildMacroProvider.CONTEXT_FILE, fd, flag).getStringValue());
357
 
////                            assertEquals(p0,     mp.getMacro(names[9], IBuildMacroProvider.CONTEXT_FILE, fd, flag).getStringValue());
358
 
////                    } catch (BuildMacroException e) { fail(e.getLocalizedMessage()); }
359
 
//////                          */                              
360
 
//                      
361
 
//                      
362
 
//              } else {
363
 
//                      // check relative path only
364
 
//                      fd = new FileContextData(p.append(EIN), p.append(AUS),opt,t);
365
 
//                      for (int i=0; i<names.length; i++) 
366
 
//                      try {   
367
 
//                              assertEquals(values0u[i], mp.getMacro(names[i], IBuildMacroProvider.CONTEXT_FILE, fd, flag).getStringValue());
368
 
//                      } catch (BuildMacroException e) { fail(e.getLocalizedMessage()); }
369
 
//              }
370
 
//              
371
 
//              // check supplier's parameters
372
 
//              assertNotNull(fd);
373
 
//              ms = mp.getSuppliers(IBuildMacroProvider.CONTEXT_FILE, fd);
374
 
//              assertNotNull(ms);
375
 
//              assertEquals(ms.length, 1);
376
 
//              assertFalse(addMacro(TEST, IBuildMacro.VALUE_TEXT, 
377
 
//                              TST[IBuildMacroProvider.CONTEXT_FILE], IBuildMacroProvider.CONTEXT_FILE, fd));
378
 
//
379
 
//              // For config #3, macros should contain lines specified in plugin.xml
380
 
//              opt = cfgs[1].getTools()[0].getOptions()[0];            
381
 
//              fd = new FileContextData(p.append(EIN), p.append(AUS),opt,cfgs[1].getTools()[0]);
382
 
//              for (int i=0; i<names.length; i++) 
383
 
//              try {
384
 
//                      assertEquals(values1[i], mp.getMacro(names[i], IBuildMacroProvider.CONTEXT_FILE, fd, flag).getStringValue());
385
 
//              } catch (BuildMacroException e) { fail(e.getLocalizedMessage()); }
386
 
//      }
387
 
        
388
 
        
389
 
        
390
 
        
391
 
        /**
392
 
         * testMacroContext()
393
 
         */
394
 
        public void rm_testMacroContext(){
395
 
                doInit();
396
 
                IBuildMacro mcfg = mp.getMacro(TEST, IBuildMacroProvider.CONTEXT_CONFIGURATION, cfgs[0], true);
397
 
                IBuildMacro mprj = mp.getMacro(TEST, IBuildMacroProvider.CONTEXT_PROJECT, mproj, true);
398
 
                IBuildMacro mwsp = mp.getMacro(TEST, IBuildMacroProvider.CONTEXT_WORKSPACE, worksp, true);
399
 
                assertNotNull(mcfg);
400
 
                assertNotNull(mprj);
401
 
                assertNotNull(mwsp);
402
 
                try {
403
 
                        assertEquals(mcfg.getStringValue(), TST[IBuildMacroProvider.CONTEXT_CONFIGURATION]);
404
 
                        assertEquals(mprj.getStringValue(), TST[IBuildMacroProvider.CONTEXT_PROJECT]);
405
 
                        assertEquals(mwsp.getStringValue(), TST[IBuildMacroProvider.CONTEXT_WORKSPACE]);
406
 
                } catch (BuildMacroException e) {
407
 
                        fail(e.getLocalizedMessage());
408
 
                }
409
 
        }
410
 
        
411
 
        /**
412
 
         * testMacroResolve()
413
 
         */
414
 
//      public void testMacroResolve(){
415
 
//              doInit();               
416
 
//              ms = mp.getSuppliers(IBuildMacroProvider.CONTEXT_WORKSPACE, worksp);
417
 
//              assertNotNull(ms);
418
 
//              String[] lst = {"AAA", "BBB", "CCC"}; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
419
 
//              assertTrue(addMacro("LST", IBuildMacro.VALUE_TEXT_LIST, lst, //$NON-NLS-1$
420
 
//                              IBuildMacroProvider.CONTEXT_WORKSPACE, worksp));                
421
 
//               assertTrue(addMacro("ONE", IBuildMacro.VALUE_TEXT, "EIN", //$NON-NLS-1$ //$NON-NLS-2$
422
 
//                              IBuildMacroProvider.CONTEXT_WORKSPACE, worksp));
423
 
//              // 
424
 
//              assertTrue(addMacro("L1", IBuildMacro.VALUE_TEXT, "nested L1-${L2}-L1", //$NON-NLS-1$ //$NON-NLS-2$
425
 
//                              IBuildMacroProvider.CONTEXT_WORKSPACE, worksp));
426
 
//              assertTrue(addMacro("L2", IBuildMacro.VALUE_TEXT, "L2-${L3}-L2", //$NON-NLS-1$ //$NON-NLS-2$
427
 
//                              IBuildMacroProvider.CONTEXT_WORKSPACE, worksp));
428
 
//              assertTrue(addMacro("L3", IBuildMacro.VALUE_TEXT, "L3-${L4}-L3", //$NON-NLS-1$ //$NON-NLS-2$
429
 
//                              IBuildMacroProvider.CONTEXT_WORKSPACE, worksp)); 
430
 
//              assertTrue(addMacro("L4", IBuildMacro.VALUE_TEXT, "L4", //$NON-NLS-1$ //$NON-NLS-2$
431
 
//                              IBuildMacroProvider.CONTEXT_WORKSPACE, worksp));
432
 
//                              
433
 
//              ms = mp.getSuppliers(IBuildMacroProvider.CONTEXT_PROJECT, mproj);
434
 
//              assertNotNull(ms);
435
 
//              assertTrue(addMacro("TWO", IBuildMacro.VALUE_TEXT, "ZWEI", //$NON-NLS-1$ //$NON-NLS-2$
436
 
//                              IBuildMacroProvider.CONTEXT_PROJECT, mproj));
437
 
//              ms = mp.getSuppliers(IBuildMacroProvider.CONTEXT_CONFIGURATION, cfgs[0]);
438
 
//              assertNotNull(ms);
439
 
//              assertTrue(addMacro("three", IBuildMacro.VALUE_TEXT, "DREI", //$NON-NLS-1$ //$NON-NLS-2$
440
 
//                              IBuildMacroProvider.CONTEXT_CONFIGURATION, cfgs[0])); 
441
 
//              
442
 
//              
443
 
//              // check normal workflow
444
 
//              try {
445
 
//                      final String pattern = "${ONE} - ${TWO} - ${three} -> ${LST}"; //$NON-NLS-1$
446
 
//                      String a = mp.resolveValue(pattern, UNKNOWN, LISTSEP,
447
 
//                              IBuildMacroProvider.CONTEXT_CONFIGURATION, cfgs[0]);
448
 
//                      String b = mp.resolveValue(pattern, UNKNOWN, LISTSEP,
449
 
//                                      IBuildMacroProvider.CONTEXT_PROJECT, mproj);
450
 
//                      String c = mp.resolveValue(pattern, UNKNOWN, LISTSEP,
451
 
//                                      IBuildMacroProvider.CONTEXT_WORKSPACE, worksp);
452
 
//                      String d = mp.resolveValue("${L1}", UNKNOWN, LISTSEP, //$NON-NLS-1$
453
 
//                                      IBuildMacroProvider.CONTEXT_WORKSPACE, worksp);
454
 
//                      String e = mp.resolveValue("${one} - ${Two} - ${THREE} -> ${lst}", UNKNOWN, LISTSEP, //$NON-NLS-1$
455
 
//                                      IBuildMacroProvider.CONTEXT_CONFIGURATION, cfgs[0]);
456
 
//                      
457
 
//                      assertEquals(a, "EIN - ZWEI - DREI -> AAA|BBB|CCC"); //$NON-NLS-1$
458
 
//                      assertEquals(b, "EIN - ZWEI - <HZ> -> AAA|BBB|CCC"); //$NON-NLS-1$
459
 
//                      assertEquals(c, "EIN - <HZ> - <HZ> -> AAA|BBB|CCC"); //$NON-NLS-1$
460
 
//                      assertEquals(d, "nested L1-L2-L3-L4-L3-L2-L1"); //$NON-NLS-1$
461
 
//                      assertEquals(e, "<HZ> - <HZ> - <HZ> -> <HZ>");  //$NON-NLS-1$  
462
 
//              } catch (BuildMacroException e) {
463
 
//                      fail("Exception while resolving: " + e.getLocalizedMessage()); //$NON-NLS-1$
464
 
//              }
465
 
//      }
466
 
        
467
 
        /**
468
 
         * testMacroResolveExceptions()
469
 
         */
470
 
        public void testMacroResolveExceptions () {
471
 
                doInit();               
472
 
 
473
 
                boolean exceptionRaised = false;
474
 
                try { // ZERO is undefined macro
475
 
                        String a = mp.resolveValue("${ONE} - ${ZERO}", null, null,  //$NON-NLS-1$
476
 
                                IBuildMacroProvider.CONTEXT_CONFIGURATION, cfgs[0]);
477
 
                } catch (BuildMacroException e) {
478
 
                        exceptionRaised = true;
479
 
                }
480
 
                assertTrue("Exception not raised for undefined macro", exceptionRaised);  //$NON-NLS-1$
481
 
                
482
 
                exceptionRaised = false;
483
 
                try { // delimiter is undefined for list
484
 
                        String a = mp.resolveValue("${LST}", null, null,  //$NON-NLS-1$
485
 
                                IBuildMacroProvider.CONTEXT_CONFIGURATION, cfgs[0]);
486
 
                } catch (BuildMacroException e) {
487
 
                        exceptionRaised = true;
488
 
                }
489
 
                assertTrue("Exception not raised for undefined delimiter", exceptionRaised);  //$NON-NLS-1$
490
 
        }
491
 
        
492
 
        /**
493
 
         * testMacroResolveLoop()
494
 
         */
495
 
//      public void testMacroResolveLoop() {
496
 
//              doInit();
497
 
//              int ctx = IBuildMacroProvider.CONTEXT_WORKSPACE;
498
 
//              Object obj = worksp;
499
 
//              ms = mp.getSuppliers(ctx, obj);
500
 
//              assertNotNull(ms);
501
 
//              
502
 
//              // check state before macros added (should be OK)
503
 
//              try {
504
 
//                      mp.checkIntegrity(ctx, obj);
505
 
//              } catch (BuildMacroException e) {
506
 
//                      fail("Macros integrity check is failed");  //$NON-NLS-1$
507
 
//              }
508
 
//
509
 
//              // create macro which references to undefined macro     
510
 
//              assertTrue(addMacro("B1", IBuildMacro.VALUE_TEXT, "B1-${B2}", ctx, obj)); //$NON-NLS-1$ //$NON-NLS-2$
511
 
//              rmMacro("B2", ctx, obj); // usually it does not exist, but to be sure...  //$NON-NLS-1$
512
 
//
513
 
//              // check state after macro added (should be exception)
514
 
//              try {
515
 
//                      mp.checkIntegrity(ctx, obj);
516
 
//                      fail("Macros misintegrity (ref to undefined) is not detected");  //$NON-NLS-1$
517
 
//              } catch (BuildMacroException e) {}
518
 
//              
519
 
//              // create "dead loop" of nested macros
520
 
//              assertTrue(addMacro("B2", IBuildMacro.VALUE_TEXT, "B2-${B3}", ctx, obj));  //$NON-NLS-1$ //$NON-NLS-2$
521
 
//              assertTrue(addMacro("B3", IBuildMacro.VALUE_TEXT, "B3-${B1}", ctx, obj));  //$NON-NLS-1$ //$NON-NLS-2$
522
 
//              
523
 
//              // check state after macros added (should be exception)
524
 
//              try {
525
 
//                      mp.checkIntegrity(ctx, obj);
526
 
//                      fail("Macros misintegrity (dead loop) is not detected");  //$NON-NLS-1$
527
 
//              } catch (BuildMacroException e) {}
528
 
//              
529
 
//              // remove "dead loop" of nested macros
530
 
//              assertTrue(rmMacro("B1", ctx, obj)); //$NON-NLS-1$
531
 
//              assertTrue(rmMacro("B2", ctx, obj)); //$NON-NLS-1$
532
 
//              assertTrue(rmMacro("B3", ctx, obj)); //$NON-NLS-1$
533
 
//              
534
 
//              // check state after macros removed (should be OK)
535
 
//              try {
536
 
//                      mp.checkIntegrity(ctx, obj);
537
 
//              } catch (BuildMacroException e) {
538
 
//                      fail("Macros integrity check is failed " + e.getLocalizedMessage());  //$NON-NLS-1$
539
 
//              }
540
 
//      }
541
 
        /**
542
 
         * testMacroResolveMake()
543
 
         */
544
 
        /*
545
 
        public void testMacroResolveMake(){
546
 
                final String p1 = "USERNAME: ";    //$NON-NLS-1$
547
 
                final String p2 = "${USERNAME} ";  //$NON-NLS-1$
548
 
                final String p3 = "PATH: ";        //$NON-NLS-1$  
549
 
                final String p4 = "${PATH} ";      //$NON-NLS-1$
550
 
                final String p5 = "HostOsName: ${HostOsName} WorkspaceDirPath: ${WorkspaceDirPath}";  //$NON-NLS-1$ 
551
 
                final String ein1 = p1 + p2 + p3;
552
 
                final String ein2 = p4 + p5;
553
 
                final String ein = ein1 + ein2;
554
 
                final String aus1 = "@USERNAME ";  //$NON-NLS-1$
555
 
                final String aus2 = "@PATH ";      //$NON-NLS-1$
556
 
                doInit();
557
 
                // Config #0 contains "variableFormat" macro = "@=". Result: 2 first macros NOT resolved 
558
 
                try {
559
 
                        UserDefinedEnvironmentSupplier env = EnvironmentVariableProvider.fUserSupplier;
560
 
                        env.createVariable("PATH","",IBuildEnvironmentVariable.ENVVAR_PREPEND,null,worksp);
561
 
                        env.createVariable("USERNAME","",IBuildEnvironmentVariable.ENVVAR_PREPEND,null,worksp);
562
 
                        functionCalled = 0;
563
 
                        String a = mp.resolveValueToMakefileFormat(ein, UNKNOWN, LISTSEP, IBuildMacroProvider.CONTEXT_CONFIGURATION, cfgs[0]);
564
 
                        String b = p1 + aus1 + p3 + mp.resolveValue(ein2, UNKNOWN, LISTSEP, IBuildMacroProvider.CONTEXT_CONFIGURATION, cfgs[0]);
565
 
                        assertEquals(a, b); // Env var names should not be resolved but converted to Makefile format                    
566
 
                        a = mp.resolveValueToMakefileFormat(ein, UNKNOWN, LISTSEP, IBuildMacroProvider.CONTEXT_PROJECT, mproj);
567
 
                        assertEquals(a, b); // Project context should return the same as default configuration
568
 
                } catch (BuildMacroException e) {
569
 
                        fail(e.getLocalizedMessage());
570
 
                }
571
 
                // Config #1 does not contain "variableFormat" macro. Result: all macros resolved.
572
 
                try {
573
 
                        String a = mp.resolveValue(ein, UNKNOWN, LISTSEP, IBuildMacroProvider.CONTEXT_CONFIGURATION, cfgs[1]);
574
 
                        String b = mp.resolveValueToMakefileFormat(ein, UNKNOWN, LISTSEP, IBuildMacroProvider.CONTEXT_CONFIGURATION, cfgs[1]);
575
 
                        assertEquals(a, b);
576
 
                } catch (BuildMacroException e) {
577
 
                        fail(e.getLocalizedMessage());
578
 
                }
579
 
                // check that "isReservedName" was not called before
580
 
                assertEquals(functionCalled & RESERVED_NAME, 0);
581
 
 
582
 
                // Config #2 contains "...Supplier" macro. Result: PATH unresolved, USERNAME resolved.
583
 
                try {
584
 
                        String a = mp.resolveValue(p1 + p2, UNKNOWN, LISTSEP, IBuildMacroProvider.CONTEXT_CONFIGURATION, cfgs[2]);
585
 
                        String b = mp.resolveValue(p5, UNKNOWN, LISTSEP, IBuildMacroProvider.CONTEXT_CONFIGURATION, cfgs[2]);
586
 
                        a = a + p3 + aus2 + b; // USERNAME: xxx PATH: @PATH HostOsName: xxx ...
587
 
                        b = mp.resolveValueToMakefileFormat(ein, UNKNOWN, LISTSEP, IBuildMacroProvider.CONTEXT_CONFIGURATION, cfgs[2]);
588
 
                        assertEquals(a, b);
589
 
                        // check that "isReservedName" has been called
590
 
                        assertEquals(functionCalled & RESERVED_NAME, RESERVED_NAME);
591
 
                } catch (BuildMacroException e) {
592
 
                        fail(e.getLocalizedMessage());
593
 
                }
594
 
        }
595
 
        */
596
 
 
597
 
        /**
598
 
         * testMacroResolveCase()
599
 
         */
600
 
//      public void testMacroResolveCase(){
601
 
//              doInit();
602
 
//              addVars();
603
 
//              final String winOut1 = "@CASETEST uppercase uppercase uppercase";   //$NON-NLS-1$
604
 
//              final String winOut2 = "@CASETEST @CASETEST @CASETEST @CASETEST";   //$NON-NLS-1$
605
 
//              
606
 
//              final String unixOut1 = "@CASETEST capitalize lowercase upper2low"; //$NON-NLS-1$
607
 
//              final String unixOut2 = "@CASETEST @CaseTest @casetest @CaSeTeSt";  //$NON-NLS-1$
608
 
//              
609
 
//              final String ein = "${CASETEST} ${CaseTest} ${casetest} ${CaSeTeSt}"; //$NON-NLS-1$
610
 
//              final int ctx = IBuildMacroProvider.CONTEXT_CONFIGURATION;
611
 
//              String a=null, b=null; 
612
 
//              try {
613
 
//                      // Config #0 contains isVariableCaseSensitive = false  
614
 
//                      a = mp.resolveValueToMakefileFormat(ein, UNKNOWN, LISTSEP, ctx, cfgs[0]);
615
 
//                      // Config #3 contains isVariableCaseSensitive = true
616
 
//                      b = mp.resolveValueToMakefileFormat(ein, UNKNOWN, LISTSEP, ctx, cfgs[3]);
617
 
//              } catch (BuildMacroException e) {
618
 
//                      fail(e.getLocalizedMessage());
619
 
//              }
620
 
//              if (windows) {
621
 
//                      assertEquals(a, winOut1);
622
 
//                      assertEquals(b, winOut2);
623
 
//              } else { // linux
624
 
//                      assertEquals(a, unixOut1);
625
 
//                      assertEquals(b, unixOut2);
626
 
//              }
627
 
//      }
628
 
 
629
 
        /**
630
 
         * testMacroSave()
631
 
         */
632
 
        
633
 
//      public void testMacroSave(){
634
 
//              final String TO_SAVE_P = "TO_SAVE_P";  //$NON-NLS-1$
635
 
//              final String TO_SAVE_W = "TO_SAVE_W";  //$NON-NLS-1$
636
 
//              doInit();               
637
 
//              ms = mp.getSuppliers(IBuildMacroProvider.CONTEXT_PROJECT, mproj);
638
 
//              assertNotNull(ms);
639
 
//              assertTrue(addMacro(TO_SAVE_P, IBuildMacro.VALUE_TEXT, TO_SAVE_P,
640
 
//                              IBuildMacroProvider.CONTEXT_PROJECT, mproj));
641
 
//              ms = mp.getSuppliers(IBuildMacroProvider.CONTEXT_WORKSPACE, worksp);
642
 
//              assertNotNull(ms);
643
 
//              assertTrue(addMacro(TO_SAVE_W, IBuildMacro.VALUE_TEXT, TO_SAVE_W,
644
 
//                              IBuildMacroProvider.CONTEXT_WORKSPACE, worksp));
645
 
//              try {
646
 
//                      // Save the buildinfo, and then remove it, to be complete
647
 
//                      ManagedBuildManager.saveBuildInfo(proj, true);
648
 
//                      ManagedBuildManager.removeBuildInfo(proj);
649
 
//                      proj.close(null);
650
 
//                      proj.open(null);
651
 
//              } catch (CoreException e) {
652
 
//                      fail("Failed on project close/open: " + e.getLocalizedMessage()); //$NON-NLS-1$
653
 
//              }
654
 
//              ms = mp.getSuppliers(IBuildMacroProvider.CONTEXT_PROJECT, mproj);
655
 
//              assertNotNull(ms);
656
 
//              String[] a = printMacros(mp.getMacros(IBuildMacroProvider.CONTEXT_PROJECT, mproj, flag), TO_SAVE_P);
657
 
//              String[] b1 = {TO_SAVE_P};
658
 
//              assertTrue(arrayContains(b1, a));
659
 
//
660
 
//              ms = mp.getSuppliers(IBuildMacroProvider.CONTEXT_WORKSPACE, worksp);
661
 
//              assertNotNull(ms);
662
 
//              a = printMacros(mp.getMacros(IBuildMacroProvider.CONTEXT_WORKSPACE, worksp, flag), TO_SAVE_W);
663
 
//              String[] b2 = {TO_SAVE_W};
664
 
//              assertTrue(arrayContains(b2, a));
665
 
//      }       
666
 
        
667
 
/*
668
 
 * Below are service methods 
669
 
 */     
670
 
        //TODO: comments for all methods
671
 
        
672
 
        // returns a list of macro's NAMES (not values).
673
 
        private String[] printMacros(IBuildMacro[] vars, String head) {
674
 
                ArrayList ar = new ArrayList(0);
675
 
                if (vars != null) {
676
 
                        if (vars.length > 0) {
677
 
                                for (int i=0; i < vars.length; i++) {
678
 
                                        try {
679
 
                                                ar.add(vars[i].getName());
680
 
                                                if (!print) continue;
681
 
                                                if ((vars[i].getMacroValueType() % 2) == 1) // not-list
682
 
                                                        //if (vars[i] instanceof EclipseVarMacro) {
683
 
                                                        if (vars[i].getName().endsWith("prompt")) {  //$NON-NLS-1$
684
 
                                                                System.out.println(head + "[" + i + "] " +  //$NON-NLS-1$  //$NON-NLS-2$
685
 
                                                                        vars[i].getName() + " = <UNREACHABLE>");  //$NON-NLS-1$ 
686
 
                                                        } else {
687
 
                                                                System.out.println(head + "[" + i + "] " +  //$NON-NLS-1$ //$NON-NLS-2$
688
 
                                                                    vars[i].getName() + " = " + vars[i].getStringValue()); //$NON-NLS-1$
689
 
                                                        }                               
690
 
                                                else {
691
 
                                                        System.out.println(head + "[" + i + "] " +  //$NON-NLS-1$ //$NON-NLS-2$
692
 
                                                                        vars[i].getName() + ":");  //$NON-NLS-1$
693
 
                                                        String[] m = vars[i].getStringListValue();      
694
 
                                                        printStrings(m, "    ");  //$NON-NLS-1$
695
 
                                                }
696
 
                                        } catch (Exception e) {}
697
 
                                }
698
 
                        } else { if (print) System.out.println(head + ": array is empty");      }  //$NON-NLS-1$
699
 
                } else { if (print) System.out.println(head + ": array is null"); }  //$NON-NLS-1$
700
 
                return (String[])ar.toArray(new String[0]);
701
 
        }
702
 
 
703
 
        private void printStrings(String[] vars, String head) {
704
 
                if (!print) return;
705
 
                if (vars != null) {
706
 
                        if (vars.length > 0) {
707
 
                                for (int j=0; j<vars.length; j++) System.out.println(head + vars[j]);
708
 
                        } else { System.out.println(head + ": array is empty"); }  //$NON-NLS-1$
709
 
                } else { System.out.println(head + ": array is null"); }  //$NON-NLS-1$
710
 
        }
711
 
        
712
 
        /* Create new project or get existing one
713
 
         * 
714
 
         * Sets "proj" "mproj" class variables
715
 
         */
716
 
        
717
 
        
718
 
        static void createManagedProject(String name) {
719
 
                IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
720
 
                proj = root.getProject(name); 
721
 
                if (proj.exists()) {
722
 
                        mproj = ManagedBuildManager.getBuildInfo(proj).getManagedProject();
723
 
                } else {
724
 
                        IWorkspace workspace = ResourcesPlugin.getWorkspace();
725
 
                        IWorkspaceDescription workspaceDesc = workspace.getDescription();
726
 
                        workspaceDesc.setAutoBuilding(false);
727
 
                        try {
728
 
                                workspace.setDescription(workspaceDesc);
729
 
                                proj = CCorePlugin.getDefault().createCProject(workspace.newProjectDescription(proj.getName()), 
730
 
                                        proj, new NullProgressMonitor(), ManagedBuilderCorePlugin.MANAGED_MAKE_PROJECT_ID);
731
 
                        
732
 
                                //      add ManagedBuildNature
733
 
                                IManagedBuildInfo info = ManagedBuildManager.createBuildInfo(proj);
734
 
                                info.setValid(true);
735
 
                                ManagedCProjectNature.addManagedNature(proj, null);
736
 
                                ManagedCProjectNature.addManagedBuilder(proj, null);
737
 
 
738
 
                                ICDescriptor desc = CCorePlugin.getDefault().getCProjectDescription(proj, true);
739
 
                                desc.remove(CCorePlugin.BUILD_SCANNER_INFO_UNIQ_ID);
740
 
                                desc.create(CCorePlugin.BUILD_SCANNER_INFO_UNIQ_ID, ManagedBuildManager.INTERFACE_IDENTITY);
741
 
                                desc.saveProjectData();
742
 
                        } catch (CoreException e) {
743
 
                                fail("Cannot create project: " + e.getLocalizedMessage()); //$NON-NLS-1$
744
 
                        }                               
745
 
                        
746
 
                        // Call this function just to avoid init problems in getProjectType();   
747
 
                        IProjectType[] projTypes = ManagedBuildManager.getDefinedProjectTypes();
748
 
                        IProjectType projType = ManagedBuildManager.getProjectType("cdt.managedbuild.target.testenv.exe"); //$NON-NLS-1$
749
 
                        assertNotNull(projType);
750
 
                        try {
751
 
                                mproj = ManagedBuildManager.createManagedProject(proj, projType);
752
 
                        } catch (BuildException e) {}
753
 
                        ManagedBuildManager.setNewProjectVersion(proj);
754
 
                        IConfiguration[] cfgs = projType.getConfigurations();
755
 
                        IConfiguration defcfg = cfgs.length > 0 ? mproj.createConfiguration(cfgs[0], projType.getId() + ".0") : null; //$NON-NLS-1$
756
 
                        for (int i = 1; i < cfgs.length; ++i) { // sic ! from 1
757
 
                                mproj.createConfiguration(cfgs[i], projType.getId() + "." + i); //$NON-NLS-1$
758
 
                        }
759
 
                        ManagedBuildManager.setDefaultConfiguration(proj, defcfg);
760
 
                }
761
 
                // open project w/o progress monitor; no action performed if it's opened
762
 
                try {
763
 
                        proj.open(null);
764
 
                } catch (CoreException e) {}                            
765
 
        }
766
 
        /**
767
 
         *  doInit() - call it at the beginning of every test
768
 
         *
769
 
         */
770
 
        private void doInit() {
771
 
                createManagedProject("Test");  //$NON-NLS-1$
772
 
                assertNotNull(proj);
773
 
                assertNotNull(mproj);
774
 
                worksp = proj.getWorkspace();
775
 
                assertNotNull(worksp);
776
 
                mp = ManagedBuildManager.getBuildMacroProvider();
777
 
                assertNotNull(mp);
778
 
                cfgs = mproj.getConfigurations();
779
 
                assertNotNull(cfgs);
780
 
                windows = System.getProperty("os.name").toLowerCase().startsWith("windows");  //$NON-NLS-1$ //$NON-NLS-2$
781
 
        }
782
 
        
783
 
        /**
784
 
         *      arrayContains
785
 
         * check that ALL variables from list a have correspondence in list b
786
 
         * @param a
787
 
         * @param b
788
 
         * @return
789
 
         */
790
 
        private boolean arrayContains(String[] a, String[] b) {
791
 
                assertNotNull(a);
792
 
                assertNotNull(b);
793
 
                for (int i=0; i<a.length; i++) {
794
 
                        boolean found = false;
795
 
                        for (int j=0; j<b.length; j++) {
796
 
                                if (a[i].equals(b[j])) {
797
 
                                        found = true;
798
 
                                        break;
799
 
                                }
800
 
                        }
801
 
                        if (!found) return false;
802
 
                }       
803
 
                return true;
804
 
        }
805
 
        /**
806
 
         *      addMacro
807
 
         * @param name
808
 
         * @param type
809
 
         * @param value
810
 
         * @param context
811
 
         * @param obj
812
 
         * @return
813
 
         */
814
 
        /*private boolean addMacro(String name, int type, String value, int context, Object obj) {
815
 
                assertNotNull(ms);
816
 
                for(int i=0; i<ms.length; i++) {
817
 
                        if (ms[i] instanceof UserDefinedMacroSupplier) {
818
 
                                return (((UserDefinedMacroSupplier)ms[i]).createMacro(name,type,value,context,obj) != null);
819
 
                        }
820
 
                }
821
 
                return false;
822
 
        }*/
823
 
        /**
824
 
         *      addMacro
825
 
         * @param name
826
 
         * @param type
827
 
         * @param value
828
 
         * @param context
829
 
         * @param obj
830
 
         * @return
831
 
         */
832
 
/*      private boolean addMacro(String name, int type, String[] value, int context, Object obj) {
833
 
                assertNotNull(ms);
834
 
                for(int i=0; i<ms.length; i++) {
835
 
                        if (ms[i] instanceof UserDefinedMacroSupplier) {
836
 
                                return (((UserDefinedMacroSupplier)ms[i]).createMacro(name,type,value,context,obj) != null);
837
 
                        }
838
 
                }
839
 
                return false;
840
 
        }*/
841
 
        /**
842
 
         *      rmMacro
843
 
         * @param name     - name of macro 
844
 
         * @param context  
845
 
         * @param obj
846
 
         * @return
847
 
         */
848
 
/*      private boolean rmMacro(String name, int context, Object obj) {
849
 
                assertNotNull(ms);
850
 
                for(int i=0; i<ms.length; i++) {
851
 
                        if (ms[i] instanceof UserDefinedMacroSupplier) {
852
 
                                return (((UserDefinedMacroSupplier)ms[i]).deleteMacro(name,context,obj) != null);
853
 
                        }
854
 
                }
855
 
                return false;
856
 
        }
857
 
        */
858
 
        /*
859
 
         * addVars() - adds macros for testMacroResolveCase
860
 
         */
861
 
//      private void addVars() {
862
 
//              int app = IBuildEnvironmentVariable.ENVVAR_APPEND;
863
 
//              String del = ""; //$NON-NLS-1$
864
 
//              UserDefinedEnvironmentSupplier usup = null;
865
 
//              usup = ManagedBuildEnvironmentTests.getSupplier(worksp, "Workspace"); //$NON-NLS-1$
866
 
//              if (usup != null) {
867
 
//                      try {
868
 
//                              usup.createVariable("casetest","lowercase",  app, del, worksp ); //$NON-NLS-1$ //$NON-NLS-2$ 
869
 
//                              usup.createVariable("CaseTest","capitalize", app, del, worksp ); //$NON-NLS-1$ //$NON-NLS-2$
870
 
//                              usup.createVariable("CaSeTeSt","upper2low",  app, del, worksp ); //$NON-NLS-1$ //$NON-NLS-2$
871
 
//                              usup.createVariable("CASETEST","uppercase",  app, del, worksp ); //$NON-NLS-1$ //$NON-NLS-2$
872
 
//                      } catch (Exception e) {
873
 
//                              fail("Failed to create workspace vars " + e.getLocalizedMessage()); //$NON-NLS-1$
874
 
//                      }
875
 
//              }
876
 
//      }
877
 
        /*
878
 
         * getFile() - open or creates sample file in current project
879
 
         */
880
 
        private IFile getFile() { 
881
 
                final String FILENAME = "main.c";            //$NON-NLS-1$
882
 
                final String FILETEXT = "int main(){\n return 0;\n}"; //$NON-NLS-1$
883
 
 
884
 
                IFile f = proj.getProject().getFile(FILENAME);
885
 
                if ( !f.exists() )
886
 
                        try {
887
 
                                f.create( new ByteArrayInputStream(FILETEXT.getBytes() ), false, null );
888
 
                } catch (CoreException e) {     fail(e.getLocalizedMessage()); }
889
 
                return f;
890
 
        }
891
 
}