Clover coverage report - DynamicJava Test Coverage (dynamicjava-20120303-r5436)
Coverage timestamp: Sat Mar 3 2012 03:02:19 CST
Overview   Package   File
    FRAMES   NO FRAMES  
file stats: LOC: 407   Methods: 89
NCLOC: 296   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
TypeDepthFirstVisitor_void.java - 0% 0% 0%
coverage
 1    package edu.rice.cs.dynamicjava.symbol.type;
 2   
 3    import edu.rice.cs.dynamicjava.symbol.*;
 4   
 5    /** An abstract implementation of a visitor over Type that does not return a value.
 6    ** This visitor implements the visitor interface with methods that
 7    ** first call forCASEDoFirst(), second visit the children, and finally
 8    ** call forCASEOnly(). (CASE is replaced by the case name.)
 9    ** By default, each of forCASEDoFirst and forCASEOnly delegates
 10    ** to a more general case. At the top of this delegation tree are
 11    ** defaultDoFirst() and defaultCase(), respectively, which (unless
 12    ** overridden) are no-ops.
 13    **/
 14    @SuppressWarnings("unused")
 15    public class TypeDepthFirstVisitor_void extends TypeVisitorRunnable1 {
 16    /**
 17    * This method is run for all cases that are not handled elsewhere.
 18    * By default, it is a no-op; subclasses may override this behavior.
 19    **/
 20  0 public void defaultCase(Type that) {}
 21   
 22    /**
 23    * This method is run for all DoFirst cases that are not handled elsewhere.
 24    * By default, it is a no-op; subclasses may override this behavior.
 25    **/
 26  0 public void defaultDoFirst(Type that) {}
 27   
 28    /* Methods to handle a node before recursion. */
 29  0 public void forTypeDoFirst(Type that) {
 30  0 defaultDoFirst(that);
 31    }
 32   
 33  0 public void forValidTypeDoFirst(ValidType that) {
 34  0 forTypeDoFirst(that);
 35    }
 36   
 37  0 public void forPrimitiveTypeDoFirst(PrimitiveType that) {
 38  0 forValidTypeDoFirst(that);
 39    }
 40   
 41  0 public void forBooleanTypeDoFirst(BooleanType that) {
 42  0 forPrimitiveTypeDoFirst(that);
 43    }
 44   
 45  0 public void forNumericTypeDoFirst(NumericType that) {
 46  0 forPrimitiveTypeDoFirst(that);
 47    }
 48   
 49  0 public void forIntegralTypeDoFirst(IntegralType that) {
 50  0 forNumericTypeDoFirst(that);
 51    }
 52   
 53  0 public void forCharTypeDoFirst(CharType that) {
 54  0 forIntegralTypeDoFirst(that);
 55    }
 56   
 57  0 public void forIntegerTypeDoFirst(IntegerType that) {
 58  0 forIntegralTypeDoFirst(that);
 59    }
 60   
 61  0 public void forByteTypeDoFirst(ByteType that) {
 62  0 forIntegerTypeDoFirst(that);
 63    }
 64   
 65  0 public void forShortTypeDoFirst(ShortType that) {
 66  0 forIntegerTypeDoFirst(that);
 67    }
 68   
 69  0 public void forIntTypeDoFirst(IntType that) {
 70  0 forIntegerTypeDoFirst(that);
 71    }
 72   
 73  0 public void forLongTypeDoFirst(LongType that) {
 74  0 forIntegerTypeDoFirst(that);
 75    }
 76   
 77  0 public void forFloatingPointTypeDoFirst(FloatingPointType that) {
 78  0 forNumericTypeDoFirst(that);
 79    }
 80   
 81  0 public void forFloatTypeDoFirst(FloatType that) {
 82  0 forFloatingPointTypeDoFirst(that);
 83    }
 84   
 85  0 public void forDoubleTypeDoFirst(DoubleType that) {
 86  0 forFloatingPointTypeDoFirst(that);
 87    }
 88   
 89  0 public void forReferenceTypeDoFirst(ReferenceType that) {
 90  0 forValidTypeDoFirst(that);
 91    }
 92   
 93  0 public void forNullTypeDoFirst(NullType that) {
 94  0 forReferenceTypeDoFirst(that);
 95    }
 96   
 97  0 public void forArrayTypeDoFirst(ArrayType that) {
 98  0 forReferenceTypeDoFirst(that);
 99    }
 100   
 101  0 public void forSimpleArrayTypeDoFirst(SimpleArrayType that) {
 102  0 forArrayTypeDoFirst(that);
 103    }
 104   
 105  0 public void forVarargArrayTypeDoFirst(VarargArrayType that) {
 106  0 forArrayTypeDoFirst(that);
 107    }
 108   
 109  0 public void forClassTypeDoFirst(ClassType that) {
 110  0 forReferenceTypeDoFirst(that);
 111    }
 112   
 113  0 public void forSimpleClassTypeDoFirst(SimpleClassType that) {
 114  0 forClassTypeDoFirst(that);
 115    }
 116   
 117  0 public void forRawClassTypeDoFirst(RawClassType that) {
 118  0 forClassTypeDoFirst(that);
 119    }
 120   
 121  0 public void forParameterizedClassTypeDoFirst(ParameterizedClassType that) {
 122  0 forClassTypeDoFirst(that);
 123    }
 124   
 125  0 public void forBoundTypeDoFirst(BoundType that) {
 126  0 forValidTypeDoFirst(that);
 127    }
 128   
 129  0 public void forIntersectionTypeDoFirst(IntersectionType that) {
 130  0 forBoundTypeDoFirst(that);
 131    }
 132   
 133  0 public void forUnionTypeDoFirst(UnionType that) {
 134  0 forBoundTypeDoFirst(that);
 135    }
 136   
 137  0 public void forVariableTypeDoFirst(VariableType that) {
 138  0 forValidTypeDoFirst(that);
 139    }
 140   
 141  0 public void forTopTypeDoFirst(TopType that) {
 142  0 forValidTypeDoFirst(that);
 143    }
 144   
 145  0 public void forBottomTypeDoFirst(BottomType that) {
 146  0 forValidTypeDoFirst(that);
 147    }
 148   
 149  0 public void forVoidTypeDoFirst(VoidType that) {
 150  0 forTypeDoFirst(that);
 151    }
 152   
 153  0 public void forWildcardDoFirst(Wildcard that) {
 154  0 forTypeDoFirst(that);
 155    }
 156   
 157    /* Methods to handle a node after recursion. */
 158  0 public void forTypeOnly(Type that) {
 159  0 defaultCase(that);
 160    }
 161   
 162  0 public void forValidTypeOnly(ValidType that) {
 163  0 forTypeOnly(that);
 164    }
 165   
 166  0 public void forPrimitiveTypeOnly(PrimitiveType that) {
 167  0 forValidTypeOnly(that);
 168    }
 169   
 170  0 public void forBooleanTypeOnly(BooleanType that) {
 171  0 forPrimitiveTypeOnly(that);
 172    }
 173   
 174  0 public void forNumericTypeOnly(NumericType that) {
 175  0 forPrimitiveTypeOnly(that);
 176    }
 177   
 178  0 public void forIntegralTypeOnly(IntegralType that) {
 179  0 forNumericTypeOnly(that);
 180    }
 181   
 182  0 public void forCharTypeOnly(CharType that) {
 183  0 forIntegralTypeOnly(that);
 184    }
 185   
 186  0 public void forIntegerTypeOnly(IntegerType that) {
 187  0 forIntegralTypeOnly(that);
 188    }
 189   
 190  0 public void forByteTypeOnly(ByteType that) {
 191  0 forIntegerTypeOnly(that);
 192    }
 193   
 194  0 public void forShortTypeOnly(ShortType that) {
 195  0 forIntegerTypeOnly(that);
 196    }
 197   
 198  0 public void forIntTypeOnly(IntType that) {
 199  0 forIntegerTypeOnly(that);
 200    }
 201   
 202  0 public void forLongTypeOnly(LongType that) {
 203  0 forIntegerTypeOnly(that);
 204    }
 205   
 206  0 public void forFloatingPointTypeOnly(FloatingPointType that) {
 207  0 forNumericTypeOnly(that);
 208    }
 209   
 210  0 public void forFloatTypeOnly(FloatType that) {
 211  0 forFloatingPointTypeOnly(that);
 212    }
 213   
 214  0 public void forDoubleTypeOnly(DoubleType that) {
 215  0 forFloatingPointTypeOnly(that);
 216    }
 217   
 218  0 public void forReferenceTypeOnly(ReferenceType that) {
 219  0 forValidTypeOnly(that);
 220    }
 221   
 222  0 public void forNullTypeOnly(NullType that) {
 223  0 forReferenceTypeOnly(that);
 224    }
 225   
 226  0 public void forArrayTypeOnly(ArrayType that) {
 227  0 forReferenceTypeOnly(that);
 228    }
 229   
 230  0 public void forSimpleArrayTypeOnly(SimpleArrayType that) {
 231  0 forArrayTypeOnly(that);
 232    }
 233   
 234  0 public void forVarargArrayTypeOnly(VarargArrayType that) {
 235  0 forArrayTypeOnly(that);
 236    }
 237   
 238  0 public void forClassTypeOnly(ClassType that) {
 239  0 forReferenceTypeOnly(that);
 240    }
 241   
 242  0 public void forSimpleClassTypeOnly(SimpleClassType that) {
 243  0 forClassTypeOnly(that);
 244    }
 245   
 246  0 public void forRawClassTypeOnly(RawClassType that) {
 247  0 forClassTypeOnly(that);
 248    }
 249   
 250  0 public void forParameterizedClassTypeOnly(ParameterizedClassType that) {
 251  0 forClassTypeOnly(that);
 252    }
 253   
 254  0 public void forBoundTypeOnly(BoundType that) {
 255  0 forValidTypeOnly(that);
 256    }
 257   
 258  0 public void forIntersectionTypeOnly(IntersectionType that) {
 259  0 forBoundTypeOnly(that);
 260    }
 261   
 262  0 public void forUnionTypeOnly(UnionType that) {
 263  0 forBoundTypeOnly(that);
 264    }
 265   
 266  0 public void forVariableTypeOnly(VariableType that) {
 267  0 forValidTypeOnly(that);
 268    }
 269   
 270  0 public void forTopTypeOnly(TopType that) {
 271  0 forValidTypeOnly(that);
 272    }
 273   
 274  0 public void forBottomTypeOnly(BottomType that) {
 275  0 forValidTypeOnly(that);
 276    }
 277   
 278  0 public void forVoidTypeOnly(VoidType that) {
 279  0 forTypeOnly(that);
 280    }
 281   
 282  0 public void forWildcardOnly(Wildcard that) {
 283  0 forTypeOnly(that);
 284    }
 285   
 286    /* Methods to recur on each child. */
 287  0 public void forBooleanType(BooleanType that) {
 288  0 forBooleanTypeDoFirst(that);
 289  0 forBooleanTypeOnly(that);
 290    }
 291   
 292  0 public void forCharType(CharType that) {
 293  0 forCharTypeDoFirst(that);
 294  0 forCharTypeOnly(that);
 295    }
 296   
 297  0 public void forByteType(ByteType that) {
 298  0 forByteTypeDoFirst(that);
 299  0 forByteTypeOnly(that);
 300    }
 301   
 302  0 public void forShortType(ShortType that) {
 303  0 forShortTypeDoFirst(that);
 304  0 forShortTypeOnly(that);
 305    }
 306   
 307  0 public void forIntType(IntType that) {
 308  0 forIntTypeDoFirst(that);
 309  0 forIntTypeOnly(that);
 310    }
 311   
 312  0 public void forLongType(LongType that) {
 313  0 forLongTypeDoFirst(that);
 314  0 forLongTypeOnly(that);
 315    }
 316   
 317  0 public void forFloatType(FloatType that) {
 318  0 forFloatTypeDoFirst(that);
 319  0 forFloatTypeOnly(that);
 320    }
 321   
 322  0 public void forDoubleType(DoubleType that) {
 323  0 forDoubleTypeDoFirst(that);
 324  0 forDoubleTypeOnly(that);
 325    }
 326   
 327  0 public void forNullType(NullType that) {
 328  0 forNullTypeDoFirst(that);
 329  0 forNullTypeOnly(that);
 330    }
 331   
 332  0 public void forSimpleArrayType(SimpleArrayType that) {
 333  0 forSimpleArrayTypeDoFirst(that);
 334  0 recur(that.ofType());
 335  0 forSimpleArrayTypeOnly(that);
 336    }
 337   
 338  0 public void forVarargArrayType(VarargArrayType that) {
 339  0 forVarargArrayTypeDoFirst(that);
 340  0 recur(that.ofType());
 341  0 forVarargArrayTypeOnly(that);
 342    }
 343   
 344  0 public void forSimpleClassType(SimpleClassType that) {
 345  0 forSimpleClassTypeDoFirst(that);
 346  0 forSimpleClassTypeOnly(that);
 347    }
 348   
 349  0 public void forRawClassType(RawClassType that) {
 350  0 forRawClassTypeDoFirst(that);
 351  0 forRawClassTypeOnly(that);
 352    }
 353   
 354  0 public void forParameterizedClassType(ParameterizedClassType that) {
 355  0 forParameterizedClassTypeDoFirst(that);
 356  0 recurOnIterableOfWildcardExtendsType(that.typeArguments());
 357  0 forParameterizedClassTypeOnly(that);
 358    }
 359   
 360  0 public void forIntersectionType(IntersectionType that) {
 361  0 forIntersectionTypeDoFirst(that);
 362  0 recurOnIterableOfWildcardExtendsType(that.ofTypes());
 363  0 forIntersectionTypeOnly(that);
 364    }
 365   
 366  0 public void forUnionType(UnionType that) {
 367  0 forUnionTypeDoFirst(that);
 368  0 recurOnIterableOfWildcardExtendsType(that.ofTypes());
 369  0 forUnionTypeOnly(that);
 370    }
 371   
 372  0 public void forVariableType(VariableType that) {
 373  0 forVariableTypeDoFirst(that);
 374  0 forVariableTypeOnly(that);
 375    }
 376   
 377  0 public void forTopType(TopType that) {
 378  0 forTopTypeDoFirst(that);
 379  0 forTopTypeOnly(that);
 380    }
 381   
 382  0 public void forBottomType(BottomType that) {
 383  0 forBottomTypeDoFirst(that);
 384  0 forBottomTypeOnly(that);
 385    }
 386   
 387  0 public void forVoidType(VoidType that) {
 388  0 forVoidTypeDoFirst(that);
 389  0 forVoidTypeOnly(that);
 390    }
 391   
 392  0 public void forWildcard(Wildcard that) {
 393  0 forWildcardDoFirst(that);
 394  0 forWildcardOnly(that);
 395    }
 396   
 397   
 398  0 public void recur(Type that) {
 399  0 that.apply(this);
 400    }
 401   
 402  0 public void recurOnIterableOfWildcardExtendsType(Iterable<? extends Type> that) {
 403  0 for (Type elt : that) {
 404  0 recur(elt);
 405    }
 406    }
 407    }
 
CloverReport generated by Clover Code Coverage v1.3.14
Sat Mar 3 2012 03:02:19 CST.		   Open Source License registered to the DrJava Project. This license of Clover is provided to support the development of DrJava only.