@Test
public void testNullOperations() throws Exception {
Value nullv = ValueFactory.createNullValue();
Value numv = ValueFactory.createValue(4d);
Value strv = ValueFactory.createValue("s");
Value falsev = numv.less(numv);
Value truev = numv.equals(numv);
assertTrue(nullv.multiply(numv).isNull());
assertTrue(numv.multiply(nullv).isNull());
assertTrue(nullv.sum(numv).isNull());
assertTrue(numv.sum(nullv).isNull());
assertTrue(strv.matches(nullv).isNull());
assertTrue(nullv.matches(strv).isNull());
assertTrue(falsev.or(nullv).isNull());
assertTrue(nullv.or(falsev).isNull());
assertTrue(truev.and(nullv).isNull());
assertTrue(nullv.and(truev).isNull());
assertTrue(numv.greaterEqual(nullv).isNull());
assertTrue(numv.equals(nullv).isNull());
assertTrue(numv.notEquals(nullv).isNull());
assertTrue(numv.less(nullv).isNull());
assertTrue(numv.lessEqual(nullv).isNull());
assertTrue(nullv.greaterEqual(numv).isNull());
assertTrue(nullv.equals(numv).isNull());
assertTrue(nullv.notEquals(numv).isNull());
assertTrue(nullv.less(numv).isNull());
assertTrue(nullv.lessEqual(numv).isNull());
}
/**
* DOCUMENT ME!
*
* @throws IncompatibleTypesException DOCUMENT ME!
*/
@Test
public void testStringValueEquals() throws IncompatibleTypesException {
Value v1 = ValueFactory.createValue("hola");
Value v2 = ValueFactory.createValue("hola");
Value v3 = ValueFactory.createValue("holA");
assertTrue((v1.equals(v2)).getAsBoolean());
assertFalse((v1.equals(v3)).getAsBoolean());
assertFalse((v2.equals(v3)).getAsBoolean());
}
public static void main(String[] args) {
Value v1 = new Value(10);
Value v2 = new Value(10);
if (v1.equals(v2)) {
System.out.println("v1과 v2는 같습니다.");
} else {
System.out.println("v1과 v2는 다릅니다.");
}
v2 = v1;
if (v1.equals(v2)) {
System.out.println("v1과 v2는 같습니다.");
} else {
System.out.println("v1과 v2는 다릅니다.");
}
}
@Override
public boolean equals(Object obj) {
if (obj instanceof HotSpotMonitorValue) {
HotSpotMonitorValue other = (HotSpotMonitorValue) obj;
return super.equals(obj)
&& eliminated == other.eliminated
&& owner.equals(other.owner)
&& slot.equals(other.slot);
}
return false;
}
public static boolean valuesEqual(Value val1, Value val2) {
if (val1 == null) {
return val2 == null;
}
if (val2 == null) {
return false;
}
if (val1 instanceof StringReference && val2 instanceof StringReference) {
return ((StringReference) val1).value().equals(((StringReference) val2).value());
}
return val1.equals(val2);
}
@Override
public boolean eval(Set<Variable> vars, ComparingCondition condition) {
Value operand1 = null;
Value operand2 = null;
if (condition.operand1 instanceof VariableHolder) {
operand1 = assign((VariableHolder) condition.operand1, vars).getValue();
} else {
operand1 = new Value(condition.operand1);
}
if (condition.operand2 instanceof VariableHolder) {
operand2 = assign((VariableHolder) condition.operand2, vars).getValue();
} else {
operand2 = new Value(condition.operand2);
}
return operand1.equals(operand2);
}
public Value copyOperation(final AbstractInsnNode insn, final Value value)
throws AnalyzerException {
Value expected;
switch (insn.getOpcode()) {
case ILOAD:
case ISTORE:
expected = BasicValue.INT_VALUE;
break;
case FLOAD:
case FSTORE:
expected = BasicValue.FLOAT_VALUE;
break;
case LLOAD:
case LSTORE:
expected = BasicValue.LONG_VALUE;
break;
case DLOAD:
case DSTORE:
expected = BasicValue.DOUBLE_VALUE;
break;
case ALOAD:
if (!((BasicValue) value).isReference()) {
throw new AnalyzerException(insn, null, "an object reference", value);
}
return value;
case ASTORE:
if (!((BasicValue) value).isReference() && !BasicValue.RETURNADDRESS_VALUE.equals(value)) {
throw new AnalyzerException(insn, null, "an object reference or a return address", value);
}
return value;
default:
return value;
}
if (!expected.equals(value)) {
throw new AnalyzerException(insn, null, expected, value);
}
return value;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
FunctionCallInstruction other = (FunctionCallInstruction) obj;
if (!Arrays.equals(args, other.args)) {
return false;
}
if (function == null) {
if (other.function != null) {
return false;
}
} else if (!function.equals(other.function)) {
return false;
}
if (name == null) {
if (other.name != null) {
return false;
}
} else if (!name.equals(other.name)) {
return false;
}
if (result == null) {
if (other.result != null) {
return false;
}
} else if (!result.equals(other.result)) {
return false;
}
return true;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
Argument other = (Argument) obj;
if (!Arrays.equals(attributes, other.attributes)) {
return false;
}
if (value == null) {
if (other.value != null) {
return false;
}
} else if (!value.equals(other.value)) {
return false;
}
return true;
}
protected boolean isSubTypeOf(final Value value, final Value expected) {
return value.equals(expected);
}
public static void main(String[] args) {
Value v1 = new Value();
Value v2 = new Value();
v1.i = v2.i = 100;
System.out.println(v1.equals(v2));
}
/**
* Run all this node's tests on two tokens. This routine assumes that the right token has only one
* fact in it, which is true at this time!
*/
boolean runTests(Token lt, Token rt, Token token) throws ReteException {
int ntests = tests.length;
ValueVector rf = rt.facts[0];
for (int i = 0; i < ntests; i++) {
if (tests[i] instanceof Test2) {
Test2 t = (Test2) tests[i];
ValueVector lf = lt.facts[t.token_idx];
if (lf == null) continue;
int lidx = t.left_idx;
int ridx = t.right_idx;
int lsubidx = t.left_sub_idx;
int rsubidx = t.right_sub_idx;
switch (t.test) {
case Test2.NEQ:
case Test2.EQ:
{
Value v1, v2;
ValueVector slot;
if (lsubidx != -1) // i.e., first variable is in a multislot
v1 = lf.get(lidx).ListValue().get(lsubidx);
else v1 = lf.get(lidx);
if (rsubidx != -1) // i.e., first variable is in a multislot
v2 = rf.get(ridx).ListValue().get(rsubidx);
else v2 = rf.get(ridx);
boolean retval = v1.equals(v2);
if (t.test == Test2.EQ && !retval) return false;
else if (t.test == Test2.NEQ && retval) return false;
}
break;
default:
throw new ReteException(
"Node2::runTests", "Test2 type not supported", String.valueOf(t.test));
}
} else { // Test1
// this is a function call! if it evals to Funcall.TRUE(),
// the test passed; FALSE(), it failed.
Test1 t = (Test1) tests[i];
Value value = t.slot_value;
switch (t.test) {
case Test1.EQ:
if (!Funcall.Execute(Eval(value, token), engine.global_context())
.equals(Funcall.TRUE())) return false;
break;
case Test2.NEQ:
if (Funcall.Execute(Eval(value, token), engine.global_context()).equals(Funcall.TRUE()))
return false;
break;
default:
throw new ReteException(
"Node2::runTests", "Test2 type not supported", String.valueOf(t.test));
}
}
}
return true;
}
/** Tests the NullValues operations */
@Test
public void testNullValueOperations() throws Exception {
Value n = ValueFactory.createNullValue();
ValueCollection b = ValueFactory.createValue(new Value[0]);
assertTrue((b.equals(n)).isNull());
assertTrue(b.notEquals(n).isNull());
Value v = ValueFactory.createValue(true);
v.and(n);
v.or(n);
// SQL UNKNOWN
assertNull((v.equals(n)).getAsBoolean());
assertNull((v.notEquals(n)).getAsBoolean());
Value i = ValueFactory.createValue(1);
i.equals(n);
i.notEquals(n);
assertTrue((i.less(n)).isNull());
assertTrue((i.lessEqual(n)).isNull());
assertTrue((i.greater(n)).isNull());
assertTrue((i.greaterEqual(n)).isNull());
Value s = ValueFactory.createValue("test");
assertTrue((s.equals(n)).isNull());
assertTrue((s.notEquals(n)).isNull());
assertTrue((s.less(n)).isNull());
assertTrue((s.lessEqual(n)).isNull());
assertTrue((s.greater(n)).isNull());
assertTrue((s.greaterEqual(n)).isNull());
s.matches(n);
Value d = ValueFactory.createValue(new Date());
assertTrue((d.equals(n)).isNull());
assertTrue((d.notEquals(n)).isNull());
assertTrue((d.less(n)).isNull());
assertTrue((d.lessEqual(n)).isNull());
assertTrue((d.greater(n)).isNull());
assertTrue((d.greaterEqual(n)).isNull());
Value t = ValueFactory.createValue(new Time(12));
assertTrue((t.equals(n)).isNull());
assertTrue((t.notEquals(n)).isNull());
assertTrue((t.less(n)).isNull());
assertTrue((t.lessEqual(n)).isNull());
assertTrue((t.greater(n)).isNull());
assertTrue((t.greaterEqual(n)).isNull());
Value ts = ValueFactory.createValue(new Timestamp(12));
assertTrue((ts.equals(n)).isNull());
assertTrue((ts.notEquals(n)).isNull());
assertTrue((ts.less(n)).isNull());
assertTrue((ts.lessEqual(n)).isNull());
assertTrue((ts.greater(n)).isNull());
assertTrue((ts.greaterEqual(n)).isNull());
assertTrue((n.equals(n)).isNull());
assertTrue((n.notEquals(n)).isNull());
assertTrue((n.less(n)).isNull());
assertTrue((n.lessEqual(n)).isNull());
assertTrue((n.greater(n)).isNull());
assertTrue((n.greaterEqual(n)).isNull());
n.matches(n);
}
private void checkDifferent(Value p1, Value p2) {
assertFalse(p1.equals(p2).getAsBoolean());
assertTrue(p1.equals(p1).getAsBoolean());
}
private void checkIO(Value v) throws IncompatibleTypesException {
Value v2 = ValueFactory.createValue(v.getType(), v.getBytes());
assertTrue((v2.equals(v)).getAsBoolean());
}
@Test
public void testToStringFromStringCoherente() throws Exception {
Value v = ValueFactory.createValue(1300.5566d);
assertTrue(
(v.equals(ValueFactory.createValueByType(v.toString(), Type.DOUBLE))).getAsBoolean());
v = ValueFactory.createValue(13.5f);
assertTrue((v.equals(ValueFactory.createValueByType(v.toString(), Type.FLOAT))).getAsBoolean());
v = ValueFactory.createValue(1300L);
assertTrue((v.equals(ValueFactory.createValueByType(v.toString(), Type.LONG))).getAsBoolean());
v = ValueFactory.createValue(false);
assertTrue(
(v.equals(ValueFactory.createValueByType(v.toString(), Type.BOOLEAN))).getAsBoolean());
v = ValueFactory.createValue("hola");
assertTrue(
(v.equals(ValueFactory.createValueByType(v.toString(), Type.STRING))).getAsBoolean());
Calendar c = Calendar.getInstance();
// month is 0-based
c.set(1980, 8, 5, 0, 0, 0);
c.set(Calendar.MILLISECOND, 0);
v = ValueFactory.createValue(d);
assertTrue((v.equals(ValueFactory.createValueByType(v.toString(), Type.DATE))).getAsBoolean());
v = ValueFactory.createValue(15);
assertTrue((v.equals(ValueFactory.createValueByType(v.toString(), Type.INT))).getAsBoolean());
v = ValueFactory.createValue((short) 13);
assertTrue((v.equals(ValueFactory.createValueByType(v.toString(), Type.SHORT))).getAsBoolean());
v = ValueFactory.createValue((byte) 5);
assertTrue((v.equals(ValueFactory.createValueByType(v.toString(), Type.BYTE))).getAsBoolean());
v = ValueFactory.createValue(new byte[] {4, 5, 7, 8, 3, 8});
assertTrue(
(v.equals(ValueFactory.createValueByType(v.toString(), Type.BINARY))).getAsBoolean());
c.set(1970, 0, 1, 22, 45, 20);
c.set(Calendar.MILLISECOND, 0);
Time t = new Time(c.getTime().getTime());
v = ValueFactory.createValue(t);
assertTrue((v.equals(ValueFactory.createValueByType(v.toString(), Type.TIME))).getAsBoolean());
v = ValueFactory.createValue(new Timestamp(2465));
assertTrue(
(v.equals(ValueFactory.createValueByType(v.toString(), Type.TIMESTAMP))).getAsBoolean());
}
public Value getOutput(int index) {
if (value.equals(Value.ZERO)) return Value.ONE;
else return Value.ZERO;
}
private void jFileExplorerWindowActionPerformed(
java.awt.event.ActionEvent evt) { // GEN-FIRST:event_jFileExplorerWindowActionPerformed
String KeyPressed = null, TmpTxt = null, S = null;
String inLine = null;
int i = 1, flag = 0, j = 0;
// KeyPressedCode = evt.getKeyCode();
KeyPressed = evt.getActionCommand();
if (KeyPressed.equals("ApproveSelection")) {
if (SaveButton == 1) /*Save button pressed in Ask_Report*/ {
BufferedWriter out = null;
try {
System.out.println(returnVal);
File selectedFile = jFileExplorerWindow.getSelectedFile();
selectedFile.delete();
out = new BufferedWriter(new FileWriter(selectedFile, true));
PrintWriter out2 = new PrintWriter(out);
ListIterator<String> litr = QueryResult.listIterator();
out2.write("RESULTS ON REPORT FOR:");
out2.write(Value);
out2.write("\n");
out2.write("-------------------------------------------------");
out2.write("\n");
System.out.print(S);
if (Value.equals("Loaner")) {
out2.printf(
"|%15s |%20s |%15s |%15s", "LoanerID", "Loaner Name", "Loaner Phone", "Contact");
out2.write("\n");
while (litr.hasNext()) {
String element = litr.next();
if (flag == 1) {
i = 1;
TmpTxt = null;
flag = 0;
}
i++;
if (i == 2) out2.printf("|%20s ", element);
else out2.printf("|%15s ", element);
if (i == 5) {
try {
out.write("\n");
flag = 1;
} catch (IOException ex) {
Logger.getLogger(FileExplorerWindow.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
} else if (Value.equals("Borrower")) {
out2.printf("|%20s |%20s |%20s", "BorrowerID", "Borrower Name", "Borrower Risk");
out2.write("\n");
if (FunctionValue.equals("Average")
|| FunctionValue.equals("Dispersion")
|| FunctionValue.equals("Standard Deviation")) {
String element = litr.next();
if (FunctionValue.equals("Average")) out.write("Average\n");
else if (FunctionValue.equals("Dispersion")) out.write("Dispersion\n");
else out.write("Standard Deviation\n");
out.write("-----------------------------\n");
out.write(element + "\n");
} else {
while (litr.hasNext()) {
String element = litr.next();
if (flag == 1) {
i = 1;
TmpTxt = null;
flag = 0;
}
i++;
out2.printf("|%20s ", element);
if (i == 4) {
out.write("\n");
flag = 1;
}
}
}
} else {
String row_name[] = {
"LoanID :",
"Amount:",
"Rate:",
"Rate Type:",
"Loan Date:",
"Loan Period:",
"Loan Type:",
"Sale Value:",
"Situation:",
"Loan Risk:",
"Mortgage Property:",
"Preselected:"
};
out2.write("\n");
if (FunctionValue.equals("Average")
|| FunctionValue.equals("Dispersion")
|| FunctionValue.equals("Standard Deviation")) {
String element = litr.next();
if (FunctionValue.equals("Average")) out.write("Average\n");
else if (FunctionValue.equals("Dispersion")) out.write("Dispersion\n");
else out.write("Standard Deviation\n");
out.write("-----------------------------\n");
out.write(element + "\n");
} else {
String element = null;
int s = QueryResult.size() / 12;
System.out.print("s" + s);
for (i = 0; i < s; i++) {
// System.out.print("QueryResult.size()12"+QueryResult.size()%12)
out.write("-----------------------------\n");
for (j = 0; j < 12; j++) {
element = litr.next();
System.out.print("row name[]=" + row_name[j]);
System.out.print("element=" + element);
out2.write(row_name[j]);
out2.write(element);
out2.write("\n");
// i++;
// System.in.read();
}
}
}
}
SaveButton = 0;
} catch (IOException ex) {
Logger.getLogger(FileExplorerWindow.class.getName()).log(Level.SEVERE, null, ex);
} finally {
try {
out.close();
} catch (IOException ex) {
Logger.getLogger(FileExplorerWindow.class.getName()).log(Level.SEVERE, null, ex);
}
}
} /*investment request/insert report*/ else {
System.out.print("");
try {
File selectedFile = jFileExplorerWindow.getSelectedFile();
BufferedReader reader = new BufferedReader(new FileReader(selectedFile));
ViewWindow a = new ViewWindow();
if (rvalue == 0) a.setVisible(true);
try {
if (rvalue == 0) {
while ((inLine = reader.readLine()) != null) {
j++;
a.copytext(inLine);
a.copytext("\n");
}
} else {
c.doUpdatePortfolio(selectedFile, reader);
}
} catch (IOException ex) {
Logger.getLogger(FileExplorerWindow.class.getName()).log(Level.SEVERE, null, ex);
}
} catch (FileNotFoundException ex) {
Logger.getLogger(FileExplorerWindow.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
this.dispose();
} // GEN-LAST:event_jFileExplorerWindowActionPerformed
public static void emitRem(
CompilationResultBuilder crb,
SPARCMacroAssembler masm,
SPARCArithmetic opcode,
Value dst,
Value src1,
Value src2,
Value scratch1,
Value scratch2,
LIRFrameState info,
SPARCDelayedControlTransfer delaySlotLir) {
int exceptionOffset = -1;
if (!isConstant(src1) && isConstant(src2)) {
assert isSimm13(crb.asIntConst(src2));
assert !src1.equals(scratch1);
assert !src1.equals(scratch2);
assert !src2.equals(scratch1);
switch (opcode) {
case IREM:
new Sra(asIntReg(src1), 0, asIntReg(dst)).emit(masm);
exceptionOffset = masm.position();
new Sdivx(asIntReg(dst), crb.asIntConst(src2), asIntReg(scratch1)).emit(masm);
new Mulx(asIntReg(scratch1), crb.asIntConst(src2), asIntReg(scratch2)).emit(masm);
delaySlotLir.emitControlTransfer(crb, masm);
new Sub(asIntReg(dst), asIntReg(scratch2), asIntReg(dst)).emit(masm);
break;
case LREM:
exceptionOffset = masm.position();
new Sdivx(asLongReg(src1), crb.asIntConst(src2), asLongReg(scratch1)).emit(masm);
new Mulx(asLongReg(scratch1), crb.asIntConst(src2), asLongReg(scratch2)).emit(masm);
delaySlotLir.emitControlTransfer(crb, masm);
new Sub(asLongReg(src1), asLongReg(scratch2), asLongReg(dst)).emit(masm);
break;
case LUREM:
exceptionOffset = masm.position();
new Udivx(asLongReg(src1), crb.asIntConst(src2), asLongReg(scratch1)).emit(masm);
new Mulx(asLongReg(scratch1), crb.asIntConst(src2), asLongReg(scratch2)).emit(masm);
delaySlotLir.emitControlTransfer(crb, masm);
new Sub(asLongReg(src1), asLongReg(scratch2), asLongReg(dst)).emit(masm);
break;
case IUREM:
GraalInternalError.unimplemented();
break;
default:
throw GraalInternalError.shouldNotReachHere();
}
} else if (isRegister(src1) && isRegister(src2)) {
Value srcLeft = src1;
switch (opcode) {
case LREM:
if (isConstant(src1)) {
new Setx(crb.asLongConst(src1), asLongReg(scratch2), false).emit(masm);
srcLeft = scratch2;
}
assert !asLongReg(srcLeft).equals(asLongReg(scratch1));
assert !asLongReg(src2).equals(asLongReg(scratch1));
// But src2 can be scratch2
exceptionOffset = masm.position();
new Sdivx(asLongReg(srcLeft), asLongReg(src2), asLongReg(scratch1)).emit(masm);
new Mulx(asLongReg(scratch1), asLongReg(src2), asLongReg(scratch1)).emit(masm);
delaySlotLir.emitControlTransfer(crb, masm);
new Sub(asLongReg(srcLeft), asLongReg(scratch1), asLongReg(dst)).emit(masm);
break;
case LUREM:
if (isConstant(src1)) {
new Setx(crb.asLongConst(src1), asLongReg(scratch2), false).emit(masm);
srcLeft = scratch2;
}
assert !asLongReg(srcLeft).equals(asLongReg(scratch1));
assert !asLongReg(src2).equals(asLongReg(scratch1));
exceptionOffset = masm.position();
new Udivx(asLongReg(srcLeft), asLongReg(src2), asLongReg(scratch1)).emit(masm);
new Mulx(asLongReg(scratch1), asLongReg(src2), asLongReg(scratch1)).emit(masm);
delaySlotLir.emitControlTransfer(crb, masm);
new Sub(asLongReg(srcLeft), asLongReg(scratch1), asLongReg(dst)).emit(masm);
break;
case IREM:
if (isConstant(src1)) {
new Setx(crb.asIntConst(src1), asIntReg(scratch2), false).emit(masm);
srcLeft = scratch2;
}
assert !asIntReg(srcLeft).equals(asIntReg(scratch1));
assert !asIntReg(src2).equals(asIntReg(scratch1));
new Sra(asIntReg(src1), 0, asIntReg(scratch1)).emit(masm);
new Sra(asIntReg(src2), 0, asIntReg(scratch2)).emit(masm);
exceptionOffset = masm.position();
new Sdivx(asIntReg(scratch1), asIntReg(scratch2), asIntReg(dst)).emit(masm);
new Mulx(asIntReg(dst), asIntReg(scratch2), asIntReg(dst)).emit(masm);
delaySlotLir.emitControlTransfer(crb, masm);
new Sub(asIntReg(scratch1), asIntReg(dst), asIntReg(dst)).emit(masm);
break;
case IUREM:
assert !asIntReg(dst).equals(asIntReg(scratch1));
assert !asIntReg(dst).equals(asIntReg(scratch2));
new Srl(asIntReg(src1), 0, asIntReg(scratch1)).emit(masm);
new Srl(asIntReg(src2), 0, asIntReg(dst)).emit(masm);
exceptionOffset = masm.position();
new Udivx(asIntReg(scratch1), asIntReg(dst), asIntReg(scratch2)).emit(masm);
new Mulx(asIntReg(scratch2), asIntReg(dst), asIntReg(dst)).emit(masm);
delaySlotLir.emitControlTransfer(crb, masm);
new Sub(asIntReg(scratch1), asIntReg(dst), asIntReg(dst)).emit(masm);
break;
default:
throw GraalInternalError.shouldNotReachHere();
}
} else {
throw GraalInternalError.shouldNotReachHere();
}
if (info != null) {
assert exceptionOffset != -1;
crb.recordImplicitException(exceptionOffset, info);
}
}
public Value merge(final Value v, final Value w) {
if (!v.equals(w)) {
return BasicValue.UNINITIALIZED_VALUE;
}
return v;
}
