private void addDuplicatedMethodError( String message, IOpenMethod method, IOpenMethod existedMethod) { ISyntaxNode newMethodSyntaxNode = method.getInfo().getSyntaxNode(); if (newMethodSyntaxNode instanceof TableSyntaxNode) { SyntaxNodeException error = SyntaxNodeExceptionUtils.createError(message, newMethodSyntaxNode); ((TableSyntaxNode) newMethodSyntaxNode).addError(error); try { TableSyntaxNode existedMethodSyntaxNode = (TableSyntaxNode) existedMethod.getInfo().getSyntaxNode(); if (existedMethodSyntaxNode != null) { existedMethodSyntaxNode.addError( SyntaxNodeExceptionUtils.createError(message, existedMethodSyntaxNode)); } } catch (Exception ex) { log.warn( "Cannot get a syntax node for the method: {}", MethodUtil.printMethod(existedMethod, new StringBuilder()), ex); } addError(error); } else { addError(new DuplicatedMethodException(message, method)); } }
@Test public void simpleLookup4paramNotEnoughValues() { IOpenMethod method = getJavaWrapper() .getOpenClass() .getMethod( "SimpleLookup4paramNotEnoughValues", new IOpenClass[] { JavaOpenClass.STRING, JavaOpenClass.getOpenClass(Double.class), JavaOpenClass.INT, JavaOpenClass.INT }); Object wrapperInstance = getJavaWrapper().newInstance(); assertEquals( new DoubleValue(0.9), method.invoke(wrapperInstance, new Object[] {"DE", 0d, 7, 3}, getJavaWrapper().getEnv())); assertEquals( new DoubleValue(1), method.invoke(wrapperInstance, new Object[] {"DE", 0d, 10, 4}, getJavaWrapper().getEnv())); assertEquals( new DoubleValue(56), method.invoke(wrapperInstance, new Object[] {"", 1d, 9, 3}, getJavaWrapper().getEnv())); }
private TestSuiteMethod createNewTestSuiteMethod(TestSuiteMethod testSuiteMethod) { IOpenMethod method = testSuiteMethod.getTestedMethod(); IOpenMethod newTargetMethod = getDeclaredMethod(method.getName(), method.getSignature().getParameterTypes()); return new TestSuiteMethod( newTargetMethod, testSuiteMethod.getHeader(), testSuiteMethod.getBoundNode()); }
@Test public void testRangeInt() { IOpenMethod method = getJavaWrapper() .getOpenClass() .getMethod("TestRangeInt", new IOpenClass[] {JavaOpenClass.INT}); Object wrapperInstance = getJavaWrapper().newInstance(); assertEquals(-10, method.invoke(wrapperInstance, new Object[] {67}, getJavaWrapper().getEnv())); assertEquals(89, method.invoke(wrapperInstance, new Object[] {99}, getJavaWrapper().getEnv())); assertEquals(78, method.invoke(wrapperInstance, new Object[] {3}, getJavaWrapper().getEnv())); }
@Test public void testArray2() { IOpenMethod method = getMethod("TestArray2", new IOpenClass[] {JavaOpenClass.STRING}); Object wrapperInstance = getJavaWrapper().newInstance(); assertEquals( 1, method.invoke(wrapperInstance, new Object[] {"1234"}, getJavaWrapper().getEnv())); assertEquals( 12, method.invoke(wrapperInstance, new Object[] {"werwe"}, getJavaWrapper().getEnv())); assertEquals( 5, method.invoke(wrapperInstance, new Object[] {"asda"}, getJavaWrapper().getEnv())); }
/** * Gets rule information of IOpenMethod instance. * * @param method IOpenMethod instance * @return rule info */ private static RuleInfo getRuleInfoForMethod(IOpenMethod method) { String methodName = method.getName(); IOpenClass[] paramClasses = method.getSignature().getParameterTypes(); Class<?> returnType = method.getType().getInstanceClass(); Class<?>[] paramTypes = OpenClassHelper.getInstanceClasses(paramClasses); RuleInfo ruleInfo = createRuleInfo(methodName, paramTypes, returnType); return ruleInfo; }
@Test public void testRangeDouble1() { IOpenMethod method = getJavaWrapper() .getOpenClass() .getMethod("TestRangeDouble1", new IOpenClass[] {JavaOpenClass.DOUBLE}); Object wrapperInstance = getJavaWrapper().newInstance(); assertEquals( -10, method.invoke(wrapperInstance, new Object[] {150.005d}, getJavaWrapper().getEnv())); assertEquals(85, method.invoke(wrapperInstance, new Object[] {0d}, getJavaWrapper().getEnv())); assertEquals( 78, method.invoke(wrapperInstance, new Object[] {6000000d}, getJavaWrapper().getEnv())); }
@Test public void testArray1() { IOpenMethod method = getJavaWrapper() .getOpenClass() .getMethod("TestArray1", new IOpenClass[] {JavaOpenClass.STRING}); Object wrapperInstance = getJavaWrapper().newInstance(); assertEquals( 0, method.invoke(wrapperInstance, new Object[] {"1234"}, getJavaWrapper().getEnv())); assertEquals(5, method.invoke(wrapperInstance, new Object[] {"-3"}, getJavaWrapper().getEnv())); assertEquals( 0, method.invoke(wrapperInstance, new Object[] {"erty"}, getJavaWrapper().getEnv())); }
@Test public void simpleLookupRange1() { IOpenMethod method = getJavaWrapper() .getOpenClass() .getMethod( "SimpleLookupRange1", new IOpenClass[] {JavaOpenClass.STRING, JavaOpenClass.getOpenClass(Double.class)}); Object wrapperInstance = getJavaWrapper().newInstance(); assertEquals( new DoubleValue(0.9), method.invoke(wrapperInstance, new Object[] {"DE", 25}, getJavaWrapper().getEnv())); assertEquals( new DoubleValue(1), method.invoke(wrapperInstance, new Object[] {"", 4}, getJavaWrapper().getEnv())); assertEquals( new DoubleValue(0), method.invoke(wrapperInstance, new Object[] {"DE", 3}, getJavaWrapper().getEnv())); }
@Test public void simpleLookup3paramRangeArray() { IOpenMethod method = getJavaWrapper() .getOpenClass() .getMethod( "SimpleLookup3paramRangeArray", new IOpenClass[] { JavaOpenClass.STRING, JavaOpenClass.getOpenClass(Double.class), JavaOpenClass.INT }); Object wrapperInstance = getJavaWrapper().newInstance(); assertEquals( new DoubleValue(0), method.invoke(wrapperInstance, new Object[] {"DE", 5d, 5}, getJavaWrapper().getEnv())); assertEquals( new DoubleValue(0.9), method.invoke(wrapperInstance, new Object[] {"DE", 7d, 3}, getJavaWrapper().getEnv())); assertEquals( new DoubleValue(1), method.invoke(wrapperInstance, new Object[] {"DE", 10d, 4}, getJavaWrapper().getEnv())); }
private void validateTestSuiteMethod(IOpenMethod method, IOpenMethod existedMethod) { if (method instanceof TableUriMethod && existedMethod instanceof TableUriMethod) { String methodHashUrl = ((TableUriMethod) method).getTableUri(); String existedMethodHashUrl = ((TableUriMethod) existedMethod).getTableUri(); if (!methodHashUrl.equals(existedMethodHashUrl)) { duplicatedMethodUrls.add(method.getInfo().getSourceUrl()); String message = ValidationMessages.getDuplicatedMethodMessage(existedMethod, method); addDuplicatedMethodError(message, method, existedMethod); } } else { throw new IllegalStateException("Implementation supports only TableUriMethod!"); } }
/** * Adds method to <code>XlsModuleOpenClass</code>. * * @param method method object */ @Override public void addMethod(IOpenMethod method) { if (method instanceof OpenMethodDispatcher) { addDispatcherMethod((OpenMethodDispatcher) method); return; } IOpenMethod m = decorateForMultimoduleDispatching(method); // Workaround needed to set the module name in the method while compile if (m instanceof AMethod) { if (((AMethod) m).getModuleName() == null) { XlsMetaInfo metaInfo = getXlsMetaInfo(); if (metaInfo != null) { IOpenSourceCodeModule sourceCodeModule = metaInfo.getXlsModuleNode().getModule(); if (sourceCodeModule instanceof IModuleInfo) { ((AMethod) m).setModuleName(((IModuleInfo) sourceCodeModule).getModuleName()); } } } } // Checks that method already exists in the class. If it already // exists then "overload" it using decorator; otherwise - just add to // the class. // IOpenMethod existedMethod = getDeclaredMethod(method.getName(), method.getSignature().getParameterTypes()); if (existedMethod != null) { if (!existedMethod.getType().equals(method.getType())) { String message = String.format( "Method \"%s\" with return type \"%s\" has already been defined with another return type (\"%s\")", method.getName(), method.getType().getDisplayName(0), existedMethod.getType().getDisplayName(0)); addDuplicatedMethodError(message, method, existedMethod); return; } if (method != existedMethod && method instanceof TestSuiteMethod) { validateTestSuiteMethod(method, existedMethod); return; } // Checks the instance of existed method. If it's the // OpenMethodDecorator then just add the method-candidate to // decorator; otherwise - replace existed method with new instance // of OpenMethodDecorator for existed method and add new one. // try { if (existedMethod instanceof OpenMethodDispatcher) { OpenMethodDispatcher decorator = (OpenMethodDispatcher) existedMethod; decorator.addMethod(undecorateForMultimoduleDispatching(m)); } else { if (m != existedMethod) { // Create decorator for existed method. // OpenMethodDispatcher dispatcher = getOpenMethodDispatcher(existedMethod); IOpenMethod openMethod = decorateForMultimoduleDispatching(dispatcher); overrideMethod(openMethod); dispatcher.addMethod(undecorateForMultimoduleDispatching(m)); } } } catch (DuplicatedMethodException e) { SyntaxNodeException error = null; if (m instanceof IMemberMetaInfo) { IMemberMetaInfo memberMetaInfo = (IMemberMetaInfo) m; if (memberMetaInfo.getSyntaxNode() != null) { if (memberMetaInfo.getSyntaxNode() instanceof TableSyntaxNode) { error = SyntaxNodeExceptionUtils.createError( e.getMessage(), e, memberMetaInfo.getSyntaxNode()); ((TableSyntaxNode) memberMetaInfo.getSyntaxNode()).addError(error); } } } boolean f = false; for (Throwable t : getErrors()) { if (t.getMessage().equals(e.getMessage())) { f = true; break; } } if (!f) { if (error != null) { addError(error); } else { addError(e); } } } } else { // Just wrap original method with dispatcher functionality. // if (dispatchingValidationEnabled && !(m instanceof TestSuiteMethod) && dimensionalPropertyPresented(m)) { // Create dispatcher for existed method. // OpenMethodDispatcher dispatcher = getOpenMethodDispatcher(m); IOpenMethod openMethod = decorateForMultimoduleDispatching(dispatcher); super.addMethod(openMethod); } else { super.addMethod(m); } } }