mockclassbuilder.java

Java的面向对象数据库系统的源代码

// You can redistribute this software and/or modify it under the terms of
// the Ozone Library License version 1 published by ozone-db.org.
//
// The original code and portions created by Joakim Ohlrogge are
// Copyright (C) 1997-@year@ by Joakim Ohlrogge. All rights reserved.
//
// $Id$
package test.ozoneDB.tools.OPP.srcgen.builder;

import com.mockobjects.Verifiable;
import com.mockobjects.ExpectationCounter;
import com.mockobjects.ExpectationList;
import com.mockobjects.util.Verifier;
import org.ozoneDB.tools.OPP.srcgen.ClassBuilder;
import org.ozoneDB.tools.OPP.srcgen.BuilderException;
import org.ozoneDB.tools.OPP.message.MessageWriter;

import java.util.List;
import java.util.Arrays;
import java.util.Iterator;
import java.lang.reflect.Modifier;

/**
 * User: Jocke
 * Date: 2003-dec-29
 * Time: 22:36:04
 */
public class MockClassBuilder implements Verifiable, ClassBuilder {
    private ExpectationCounter initCount = new ExpectationCounter("init calls");
    private ExpectationList beginClassExpectations = new ExpectationList("beginClass");
    private ExpectationCounter endClassCount = new ExpectationCounter("endClass calls");
    private ExpectationList makeMethodExpectations = new ExpectationList("makeMethod");
    private ExpectationList makeConstructorExpectations = new ExpectationList("makeConstructor");
    private int expectedEndClassCount;

    // class to check methods and constructors
    private class MethodDescriptor {
        public int lockLevel = 0;
        public int modifier = 0;
        public String name;
        public String returnType;
        public List parameters;
        public List exceptions;

        public MethodDescriptor(int modifier, String returnType, String name, ClassBuilder.Parameter parameters[], String exceptions[], int lockLevel) {
            this.modifier = modifier;
            this.name = name;
            this.returnType = returnType;
            this.lockLevel = lockLevel;
            this.parameters = Arrays.asList(parameters);
            this.exceptions = Arrays.asList(exceptions);
        }

        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof MethodDescriptor)) return false;

            final MethodDescriptor methodDescriptor = (MethodDescriptor) o;

            if (lockLevel != methodDescriptor.lockLevel) return false;
            if (modifier != methodDescriptor.modifier) return false;
            if (!exceptions.equals(methodDescriptor.exceptions)) return false;
            if (name != null ? !name.equals(methodDescriptor.name) : methodDescriptor.name != null) return false;
            if (!parameters.equals(methodDescriptor.parameters)) return false;
            if (returnType != null ? !returnType.equals(methodDescriptor.returnType) : methodDescriptor.returnType != null) return false;

            return true;
        }

        public int hashCode() {
            int result;
            result = lockLevel;
            result = 29 * result + modifier;
            result = 29 * result + (name != null ? name.hashCode() : 0);
            result = 29 * result + (returnType != null ? returnType.hashCode() : 0);
            result = 29 * result + parameters.hashCode();
            result = 29 * result + exceptions.hashCode();
            return result;
        }

        public String toString() {
            StringBuffer result = new StringBuffer();
            result.append(Modifier.toString(modifier)).append(" ");
            result.append(returnType).append(" ").append(name).append(" (");
            for (Iterator iterator = parameters.iterator(); iterator.hasNext();) {
                ClassBuilder.Parameter parameter = (ClassBuilder.Parameter) iterator.next();
                result.append(parameter);
                if (iterator.hasNext()) {
                    result.append(", ");
                }
            }
            result.append(")");
            if (!exceptions.isEmpty()) {
                result.append(" throws ");
            }
            for (Iterator iterator = exceptions.iterator(); iterator.hasNext();) {
                String exception = (String) iterator.next();
                result.append(exception);
                if (iterator.hasNext()) {
                    result.append(", ");
                }
            }
            result.append("\n");
            result.append("LockLevel: " + lockLevel);
            return result.toString();
        }
    }

    private class ClassDescriptor {
        public int modifier = 0;
        public String fullName;
        public String superClass;
        public List interfaces;

        public ClassDescriptor(int modifier, String fullName, String superClass, String interfaces[]) {
            this.modifier = modifier;
            this.fullName = fullName;
            this.superClass = superClass;
            this.interfaces = Arrays.asList(interfaces);
        }

        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof ClassDescriptor)) return false;

            final ClassDescriptor classDescriptor = (ClassDescriptor) o;

            if (modifier != classDescriptor.modifier) return false;
            if (!fullName.equals(classDescriptor.fullName)) return false;
            if (!interfaces.equals(classDescriptor.interfaces)) return false;
            if (!superClass.equals(classDescriptor.superClass)) return false;

            return true;
        }

        public int hashCode() {
            int result;
            result = modifier;
            result = 29 * result + fullName.hashCode();
            result = 29 * result + superClass.hashCode();
            result = 29 * result + interfaces.hashCode();
            return result;
        }

        public String toString() {
            return Modifier.toString(modifier) + " " + fullName + " " + (superClass.equals("") ? "" : " extends " + superClass) + " " +
                    printInterfaces();
        }

        private String printInterfaces() {
            if (interfaces.isEmpty()) {
                return "";
            } else {
                String result = "interfaces ";
                for (Iterator iterator = interfaces.iterator(); iterator.hasNext();) {
                    String itf = (String) iterator.next();
                    result += itf;
                    if (iterator.hasNext()) {
                        result += ", ";
                    }
                }
                return result;
            }
        }
    }


    public void setupInit(boolean recieve) {
        if (recieve) {
            initCount.setExpected(1);
        } else {
            initCount.setExpectNothing();
        }
    }

    public void setupBeginClass(int modifier, String fullName, String superClass, String interfaces[]) {
        beginClassExpectations.addExpected(new ClassDescriptor(modifier, fullName, superClass, interfaces));
        endClassCount.setExpected(++expectedEndClassCount);
    }

    public void setupMakeConstructor(int modifier, ClassBuilder.Parameter parameters[], String exceptions[]) throws BuilderException {
        makeConstructorExpectations.addExpected(new MethodDescriptor(modifier, null, null, parameters, exceptions, 0));
    }

    public void setupMakeMethod(int modifier, String name, ClassBuilder.Parameter parameters[], String returnType, String exceptions[], int lockLevel) throws BuilderException {
        makeMethodExpectations.addExpected(new MethodDescriptor(modifier, returnType, name, parameters, exceptions, lockLevel));
    }

    public void init(MessageWriter msgWriter) {
        initCount.inc();
    }

    public void beginClass(int modifier, String fullName, String superClass, String interfaces[]) throws BuilderException {
        beginClassExpectations.addActual(new ClassDescriptor(modifier, fullName, superClass, interfaces));
    }

    public void makeConstructor(int modifier, ClassBuilder.Parameter parameters[], String exceptions[]) throws BuilderException {
        makeConstructorExpectations.addActual(new MethodDescriptor(modifier, null, null, parameters, exceptions, 0));
    }

    public void makeMethod(int modifier, String name, ClassBuilder.Parameter parameters[], String returnType, String exceptions[], int lockLevel) throws BuilderException {
        makeMethodExpectations.addActual(new MethodDescriptor(modifier, returnType, name, parameters, exceptions, lockLevel));
    }

    public void endClass() throws BuilderException {
        endClassCount.inc();
    }

    public void verify() {
        Verifier.verifyObject(this);
    }
}