EMMA Coverage Report (generated Fri Jul 28 01:51:09 CEST 2006)
[all classes][org.jtiger.framework]

COVERAGE SUMMARY FOR SOURCE FILE [ArgsConverterFactory.java]

nameclass, %method, %block, %line, %
ArgsConverterFactory.java100% (3/3)100% (8/8)99%  (387/392)100% (98/98)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class ArgsConverterFactory100% (1/1)100% (2/2)100% (7/7)100% (3/3)
ArgsConverterFactory (): void 100% (1/1)100% (3/3)100% (2/2)
newArgsToFixtureRunnerParams (): ArgsConverter 100% (1/1)100% (4/4)100% (1/1)
     
class ArgsConverterFactory$ArgReadState100% (1/1)100% (4/4)95%  (106/111)99%  (8/8)
<static initializer> 100% (1/1)100% (74/74)100% (8/8)
ArgsConverterFactory$ArgReadState (String, int): void 100% (1/1)100% (5/5)100% (1/1)
valueOf (String): ArgsConverterFactory$ArgReadState 100% (1/1)82%  (23/28)82%  (0,8/1)
values (): ArgsConverterFactory$ArgReadState [] 100% (1/1)100% (4/4)100% (1/1)
     
class ArgsConverterFactory$ArgsConverterImpl100% (1/1)100% (2/2)100% (274/274)100% (87/87)
ArgsConverterFactory$ArgsConverterImpl (): void 100% (1/1)100% (3/3)100% (2/2)
convert (String []): Args 100% (1/1)100% (271/271)100% (85/85)

1/*
2 * JTiger Unit Testing Framework for J2SE 1.5
3 * Copyright (C) 2005 Tony Morris
4 *
5 * This software is licenced under the
6 * Common Public Licence version 1.0
7 * http://www.opensource.org/licenses/cpl1.0.php
8 *
9 * You received a copy of this licence with this software.
10 */
11package org.jtiger.framework;
12 
13import static org.jtiger.framework.ClassAliasMappingFactory.newClassAliasMapping;
14import java.util.ArrayList;
15import java.util.LinkedList;
16import java.util.List;
17import static org.jtiger.framework.FixturesRunnerConfigFactory.newFixturesRunnerConfig;
18import static org.jtiger.framework.SequenceFactory.newSequence;
19import static org.jtiger.framework.ArgsFactory.newArgs;
20import org.jtiger.framework.junit.JUnitTestDefinition;
21import org.jtiger.framework.junit.JUnitSetUpTearDown;
22 
23final class ArgsConverterFactory
24{
25    private ArgsConverterFactory()
26    {
27 
28    }
29 
30    static ArgsConverter newArgsToFixtureRunnerParams()
31    {
32        return new ArgsConverterImpl();
33    }
34 
35    enum ArgReadState
36    {
37        NONE,
38        FIXTURE_CLASSES,
39        DEFINITION_CLASS,
40        SUTD_CLASS,
41        CATEGORIES,
42        RESULT_HANDLER_CLASS,
43        RESULT_HANDLER_PARAMETERS;
44    }
45 
46    private static final class ArgsConverterImpl implements ArgsConverter
47    {
48        ArgsConverterImpl()
49        {
50 
51        }
52 
53        public Args convert(final String... args) throws ClassNotFoundException, NullPointerException
54        {
55            if(args == null)
56            {
57                throw new NullPointerException();
58            }
59 
60            if(args.length == 0)
61            {
62                return null;
63            }
64 
65            final List<String> fixtureClassNames = new LinkedList<String>();
66            String definitionClassName = null;
67            String sutdClassName = null;
68            boolean haltOnFailure = false;
69            final List<String> categories = new LinkedList<String>();
70            String resultHandlerClassName = null;
71            final List<String> resultHandlerParameters = new LinkedList<String>();
72 
73            ArgReadState state = ArgReadState.NONE;
74 
75            for(String arg : args)
76            {
77                if(arg.equalsIgnoreCase(FixturesRunnerMain.ARG_FIXTURE_CLASSES))
78                {
79                    state = ArgReadState.FIXTURE_CLASSES;
80                }
81                else if(arg.equalsIgnoreCase(FixturesRunnerMain.ARG_DEFINITION_CLASS))
82                {
83                    state = ArgReadState.DEFINITION_CLASS;
84                }
85                else if(arg.equalsIgnoreCase(FixturesRunnerMain.ARG_SUTD_CLASS))
86                {
87                    state = ArgReadState.SUTD_CLASS;
88                }
89                else if(arg.equalsIgnoreCase(FixturesRunnerMain.ARG_HALT_ON_FAILURE))
90                {
91                    haltOnFailure = true;
92                    state = ArgReadState.NONE;
93                }
94                else if(arg.equalsIgnoreCase(FixturesRunnerMain.ARG_JUNIT))
95                {
96                    definitionClassName = JUnitTestDefinition.class.getName();
97                    sutdClassName = JUnitSetUpTearDown.class.getName();
98                    state = ArgReadState.NONE;
99                }
100                else if(arg.equalsIgnoreCase(FixturesRunnerMain.ARG_CATEGORIES))
101                {
102                    state = ArgReadState.CATEGORIES;
103                }
104                else if(arg.equalsIgnoreCase(FixturesRunnerMain.ARG_RESULT))
105                {
106                    state = ArgReadState.RESULT_HANDLER_CLASS;
107                }
108                else if(arg.equalsIgnoreCase(FixturesRunnerMain.ARG_RESULT_PARAMETERS))
109                {
110                    state = ArgReadState.RESULT_HANDLER_PARAMETERS;
111                }
112                else
113                {
114                    if(state == ArgReadState.NONE)
115                    {
116                        return null;
117                    }
118                    else if(state == ArgReadState.FIXTURE_CLASSES)
119                    {
120                        fixtureClassNames.add(arg);
121                    }
122                    else if(state == ArgReadState.DEFINITION_CLASS && definitionClassName == null)
123                    {
124                        definitionClassName = arg;
125                        state = ArgReadState.NONE;
126                    }
127                    else if(state == ArgReadState.SUTD_CLASS && sutdClassName == null)
128                    {
129                        sutdClassName = arg;
130                        state = ArgReadState.NONE;
131                    }
132                    else if(state == ArgReadState.CATEGORIES)
133                    {
134                        categories.add(arg);
135                    }
136                    else if(state == ArgReadState.RESULT_HANDLER_CLASS && resultHandlerClassName == null)
137                    {
138                        resultHandlerClassName = arg;
139 
140                        final String aliasedName = newClassAliasMapping().getMappedClassName(resultHandlerClassName);
141 
142                        if(aliasedName != null)
143                        {
144                            resultHandlerClassName = aliasedName;
145                        }
146 
147                        state = ArgReadState.NONE;
148                    }
149                    else if(state == ArgReadState.RESULT_HANDLER_PARAMETERS)
150                    {
151                        resultHandlerParameters.add(arg);
152                    }
153                }
154            }
155 
156            final List<Class<?>> fixtureClasses = new ArrayList<Class<?>>(fixtureClassNames.size());
157            Class<? extends TestDefinition> definitionClass = null;
158            Class<? extends SetUpTearDown> sutdClass = null;
159            Class<? extends FixtureResultsHandler> resultHandlerClass = null;
160 
161            for(String fixtureClassName : fixtureClassNames)
162            {
163                fixtureClasses.add(Class.forName(fixtureClassName));
164            }
165 
166            if(definitionClassName != null)
167            {
168                final Class<?> c = Class.forName(definitionClassName);
169 
170                if(TestDefinition.class.isAssignableFrom(c))
171                {
172                    definitionClass = c.asSubclass(TestDefinition.class);
173                }
174            }
175 
176            if(sutdClassName != null)
177            {
178                final Class<?> c = Class.forName(sutdClassName);
179 
180                if(SetUpTearDown.class.isAssignableFrom(c))
181                {
182                    sutdClass = c.asSubclass(SetUpTearDown.class);
183                }
184            }
185 
186            if(resultHandlerClassName != null)
187            {
188                final Class<?> c = Class.forName(resultHandlerClassName);
189 
190                if(FixtureResultsHandler.class.isAssignableFrom(c))
191                {
192                    resultHandlerClass = c.asSubclass(FixtureResultsHandler.class);
193                }
194            }
195 
196            return newArgs(newFixturesRunnerConfig(
197                    newSequence(fixtureClasses.toArray(new Class<?>[fixtureClasses.size()])),
198                    definitionClass,
199                    sutdClass,
200                    haltOnFailure,
201                    categories.toArray(new String[categories.size()])),
202                    resultHandlerClass,
203                    newSequence(resultHandlerParameters.toArray(new String[resultHandlerParameters.size()])));
204        }
205    }
206}

[all classes][org.jtiger.framework]
EMMA 2.0.5312 (C) Vladimir Roubtsov