void copy(Source source, Dest dest) {
  dest.setFoo(source.foo());
  dest.setBar(source.baz());
  // 不拷贝baz，baz的处理在别的地方做。
  // 还有其他的乱七八糟的拷贝
}

Source source = new Source();
source.setFoo("foo");
source.setBar("bar");
source.setBaz("baz");
Dest dest = new Dest();
copy(source, dest);
assertEquals("foo", dest.getFoo());
assertEquals("bar", dest.bar());
assertNull(dest.baz());

expect(source.getFoo()).andReturn("foo");
dest.setFoo("foo");
expect(source.getBar()).andReturn("bar");
dest.setBar("bar");
// 不用管baz了，所有我们没说的一概不允许发生！

dest.setFoo(source.getFoo());

dest.setFoo(source.getFoo());
dest.setBar(source.getBar());
// do not copy baz as it is taken care of separately
// other set(get())

Map<String, String> params(int id) {
  return ImmutableMap.of(
    "m", "Get",
    "id", id
  );
}

void doFoo(int id) {
  service.call(params(id));
}

service.call(ImmutableMap.of(
    "m", "Get",
    "id", id
  ));

replay();

doFoo(id);

service.call(Foo.params(id));

replay();

doFoo(id);

assertEquals(ImmutableMap.of(
    "m", "Get",
    "id", id
  ), Foo.params(id));

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

Map<String, String>

String idValue = map.get("id");
if (idValue == null) {
  throw ...;
}
int id = Integer.parseInt(idValue);

String name = map.get("name");
if (name == null) {
  name = "";
}

String sexValue = map.get("sex");
if (sexValue == null) {
  throw ...;
}
Gender sex = Gender.valueOf(sexValue);
...

public final class PropertyConverter<T> {
  private final Class<T> targetType;
  
  private PropertyConverter(Class<T> targetType) {...}

  public static <T> PropertyConverter<T> to(Class<T> targetType) {
    return new PropertyConverter<T>(targetType);
  }

  public T from(final Map<String, String> map) {
    return Proxy.newProxyInstance(
      new Class[]{targetType}, targetType.getClassLoader(), new InvocationHandler() {
        public Object invoke(Object proxy, Method method, Object[] args) {
          String value = map.get(method.getName());
          if (value == null) {
            Object defaultValue = method.getDefaultValue();
            if (defaultValue == null) {
              throw ...;
            }
            return defaultValue;
          }
          return convert(value, method.getReturnType());
        }
    });
  }
}

@interface Foo {
  int id();
  String name() default "";
  Gender sex();
}

Map<String, String> map = ...;
Foo foo = PropertyConverter.to(Foo.class).from(map);
foo.id();
foo.name();

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

public void testDoSomethingBad() {
  initializeSomething();
  try {
    doSomethingBad();
    fail();
  } catch (FooException e) {}
}

• initializeSomething()不许出错
• 在initializeSomething()之后doSomethingBad()要出错

@Test
public void testInitializeSomething() {
  initializeSomething();
}

@Test(expected=FooException.class)
public void testDoSomethingBadAfterInitializeSomething() {
  initializeSomething();
  doSomethingBad();
}

• 它等于代码里的逻辑分支。如果没有抛异常，它执行fail()，而如果抛了异常，它进入catch()。而测试里的逻辑分支味道很坏。它让你的代码容易出错（比如，你忘了fail怎么办？测试一样是绿的，但是你的bug还躲在那）。而且，它让测试代码不能达到100%的分支覆盖率。本来如果用annotation的话，如果出现了initializeSomething()抛出异常的情况，覆盖率马上不是100%了，你可以很容易地发现问题。
• 冗长烦琐。测试写的不象spec，而象过程形代码。
• 这个try-fail-catch只在你检查Exception的时候成立。如果万一你要检查一个Error甚至是JUnit的AssertionFailedError，完了，你连fail()抛的异常也给截获了。

public void testDoSomethingBad() {
  initializeSomething();
  expectException(FooException.class);
  doSomethingBad();
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

module org
  module codehaus
    module rparsec
      class Parser
        ...
      end
    end
  end
end

module RParsec
  class Parser
    ...
  end
end

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

class MyModule extends AbstractModule {
  @Provide @Singleton
  public Foo foo(FooImpl impl) {
    return impl;
  }

  @Provide @LittleStrong
  public Bar bar(A a, B b) {
    return new BarImpl(a, b);
  }
}

// 用来代替
bind(Foo.class).to(FooImpl.class).in(Singleton.class);
bind(Bar.class).annotatedWith(LittleStrong.class).toProvider(new Provider<Bar>() {
  @Inject A a;
  @Inject B b;
  public Bar get() {
    return new BarImpl(a, b);
  }
});

public class FooTest extends PorkTest {
  @Mock private Foo foo;
  @Mock private Bar bar;
}

public class User {
  @Param("username") String name;
  @Param("id") int id;
}
String queryString = QueryStringBuilder.build(new User("ajoo", 1));

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

public class LionHeadTest extends PorkMockTest {
  public void testHuoHou() {
    LionHead head = mock(LionHead.class);
    head.bite();
    replay();
    cook(head);
    // 忘记吧，忘记吧。忘记是一种幸福。能忘记的人才能快乐地吃狮子头啊！
  }
}

public class LionHeadTest extends PorkMockTest {
  private final LionHead head = mock(LionHead.class);
  
  public void testEat() {...}
  public void testEatAgain() {...}
  public void testOneMorePlease() {...}
  ...
}

class LionHeadTest extends PorkMockTest {
  private LionHead head;

  @Override protected void setUp() throws Exception {
    super.setUp();
    head = mock(LionHead.class);
  }

  ...
}

public class LionHeadTest extends PorkMockTest {
 @Mock  private LionHead head;
  
  public void testEat() {...}
  public void testEatAgain() {...}
  public void testOneMorePlease() {...}
  ...
}

@Target(FIELD)
@Retention(RUNTME)
protected @interface Mock {}

@Override public void runBare() {
  mockFields(getClass(), this);
  super.runBare();
}

private void mockFields(Class cls, Object obj) {
  Field[] fields = cls.getDecalredFields();
  for (Field field : fields) {
    if (field.getAnnotation(Mock.class) != null) {
      field.setAccessible(true);
      field.set(obj, mock(field.getType());
    }
  }
  Class superclass = cls.getSuperclass();
  if (superclass != null) {
    mockFields(superclass, obj);
  }
}

public class FeastTest extends PorkMockTest {
  @Mock private Lobster lobster;
  @Mock private Oyster oyster;
  @Mock private BirdNest nest;
  @Mock private ElephantNoseClam clam;

  ...
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

public class PorkMockTest extends TestCase {
  private IMocksControl control = null;
  private boolean replayed = false;
  private boolean verified = false;

  @Override protected void runTest() throws Throwable {
    super.runTest();
    if (replayed && !verified) {
      verify();
    }
  }
  private IMocksControl control() {
    if (control == null) {
      control = EasyMock.createMockControl();
    }
  }

  public <T> T mock(Class<T> type) {
    return control.createMock(type);
  }

  protected void replay() {
    control().replay();
    replayed = true;
  }

  protected void verify() {
    verified = true;
    control().verify();
  }
}

public class LionHeadTest extends PorkMockTest {
  public void testHuoHou() {
    LionHead head = mock(LionHead.class);
    head.bite();
    replay();
    cook(head);
    // 忘记吧，忘记吧。忘记是一种幸福。能忘记的人才能快乐地吃狮子头啊！
  }
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

public class KnightModule {
  @Provide
  public Knight knight() {
    ...
  }

  @Provide
  public Quest quest() {
    ...
  }

  ...
}

@Configuration
public class KnightConfig {
  @Bean public Knight knight() {
    KnightOfTheRoundTable knight = new KnightOfTheRoundTable("Bedivere");
    knight.setQuest(quest());
    return knight;
  }

  @Bean public Quest quest() {
     return new HolyGrailQuest();
  }

  @Bean @SpringAdvice("execution(* *.embarkOnQuest(..))")
  public MinstrelInterceptor minstelAdvice() {
     return new MinstrelInterceptor();
  }
}

Knight knight = (Knight) ctxt.getBean("knight");

Knight knight = new KnightModule().knight();

@Bean(scope = DefaultScopes.SINGLETON)
public Person rod() {
  return new Person("Rod Johnson");
}

@Bean(scope = DefaultScopes.PROTOTYPE)
public Book book() {
  Book book = new Book("Expert One-on-One J2EE Design and Development");
  book.setAuthor(rod());  // rod() method is actually a bean reference !
  return book;
}

<property name="author" ref="rod"/>

book.setAuthor(rod());

@Provide @Singleton
public Person bob() {
  return new Person("crazybob");
}

@Provide
public Book book(Person author) {
  Book book = new Book("Guice!");
  book.setAuthor(author);
  return book;
}

class BookModule {
  private final String title;

  BookModule(String title) {
    this.title = title;
  }

  @Provide @Singleton
  public Person bob() {
    return new Person("crazybob");
  }

  @Provide
  public Book book(Person author) {
    Book book = new Book(title);
    book.setAuthor(author);
    return book;
  }
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

ListableBeanFactory beanFactory = mock(ListableBeanFactory.class);
expect(beanFactory.getBeanDefinitions()).andReturn(beanNames);
replay();
...
verify();

binder.bind(List.class).annotatedWith(Names.named("test")).to(ArrayList.class).in(Singleton.class);

Binder binder = mock(Binder.class);
AnnotatedBindingBuilder annotatedBuilder = mock(AnnotatedBindingBuilder.class);
LinkedBindingBuilder linkedBuilder = mock(LikedBindingBuilder.class);
ScopedBindingBuilder scopedBuilder = mock(ScopedBindingBuilder.class);
expect(binder.bind(List.class)).andReturn(annotatedBuilder);
expect(annotatedBuilder.annotatedWith(Names.named("test"))).andReturn(linkedBuilder);
expect(linkedBuilder.to(ArayList.class)).andReturn(scopedBuilder);
scopedBuilder.in(Singleton.class);

Binder binder = mockBinder();
binder.bind(List.class).annotatedWith(Names.named("test")).to(ArrayList.class).in(Singleton.class);

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

public class SomeTest extends TestCase {
   private final IMocksControl control = EasyMock.createStrictControl();
   private final Connection connection = control.createMock(Connection.class);
   @Override protected void tearDown() {
     control.verify();
     // other cleanups.
   }
   public void test1() {
      expect(connection.createStatement()).andReturn(null);
      ...
      control.replay();
      ...
   }
}

public class SomeTest extends TestCase {
  public static Test suite() {
    return new AjooTestSuite(SomeTest.class);
  }
  
  // 哈哈。终于可以用final和initializer了！
  private final IMocksControl control = EasyMock.createStrictControl();
  private final Connection conn = control.createMock(Connection.class);

  @Verify
  public void verifyMocks() {
    control.verify();
  }

  @Shared
  public static XmlObject provideXml() {
    // ... read xml file and parse.
    return xmlObj;
  }
  
  private final XmlObj;

  // the shared xmlObj will be injected for each test case.
  public SomeTest(String name, XmlObject obj) {
    super(name);
    this.xmlOj = obj;
  }

  @BeforeSuite
  public static void initialize() {
    // some suite level initialization. No more TestSetup!
  }
  @AfterSuite
  public static void deinitialize() {
    // suite level deinitialization.
  }
  @BeforeTest
  public void setupMocks() {
    expect(conn.createStatement()).andReturn(null);
  }
  @ExceptionExpected(NullPointerException.class)
  public void test1() {
    throw new NullPointerException();
  }
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

public class Portion {
  public double getPercent();
  public double getWeight();
  public double getAmount();
  public double getTotal();
  public static Portion fromPercent(double total, double percent);
  public static Portion fromWeight(double total, double weight);
  public static Portion fromAmount(double total, double amount);
}

public class Portion {
  private final double total;
  private final double amount;
  Portion(double total, double amount) {
    this.total = total;
    this.amount = amount;
  }
  public double getPercent() {
    return getWeight()*100;
  }
  public double getWeight() {
    return total==0?0:amount/total;
  }
  public double getAmount() {
    return amount;
  }
  public double getTotal() {
    return total;
  }
  public static Portion fromPercent(double total, double percent) {
    return new Portion(total, total*percent/100);
  }
  public static Portion fromWeight(double total, double weight) {
    return new Portion(total, total*weight);
  }
  public static Portion fromAmount(double total, double amount) {
    return new Portion(total, amount);
  }
}

assertEquals(weight, Portion.fromWeight(777, weight).getWeight(), 0)

public class Portion {
  private final double total;
  private final double amount;
  private final double percent;
  private final double weight;
  Portion(double total, double amount, double percent, double weight) {
    this.total = total;
    this.amount = amount;
    this.percent = percent;
    this.weight = weight;
  }
  public double getPercent() {
    return percent;
  }
  public double getWeight() {
    return weight;
  }
  public double getAmount() {
    return amount;
  }
  public double getTotal() {
    return total;
  }
  public static Portion fromPercent(double total, double percent) {
    return new Portion(total, total*percent/100, percent, percent/100);
  }
  public static Portion fromWeight(double total, double weight) {
    return new Portion(total, total*weight, weight*100, weight);
  }
  public static Portion fromAmount(double total, double amount) {
    double weight = total==0?0:amount/total;
    return new Portion(total, amount, weight*100, weight);
  }
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

public void test1() {
  Account acct = new Account();
  acct.setName("test");
  acct.setType(TypeEnum.Type1);
  acct.setActive(true);
  Result result = runSomeApi(acct);
  assertEquals("test", result.getName());
  assertTrue(result.isActive());
  ResultType[] arr = result.getTypes();
  assertEquals(1, arr.length);
  assertEquals("type1", arr[0].getName());
}

public void test2() {
  Account acct = new Account();
  acct.setName("test");
  acct.setType(TypeEnum.Type2);
  acct.setActive(true);
  Result result = runSomeApi(acct);
  assertEquals("test", result.getName());
  assertTrue(result.isActive());
  ResultType[] arr = result.getTypes();
  assertEquals(1, arr.length);
  assertEquals("type2", arr[0].getName());
}
public void testNull(){
  Account acct = new Account();
  acct.setName("test");
  acct.setType(null);
  acct.setActive(true);
  Result result = runSomeApi(acct);
  assertEquals("test", result.getName());
  assertTrue(result.isActive());
  ResultType[] arr = result.getTypes();
  assertEquals(2, arr.length);
  assertEquals("type1", arr[0].getName());
  assertEquals("type2", arr[1].getName());
}

private String name = "test";
private getResult(TypeEnum type) {
  Account acct = new Account();
  acct.setName(name);
  acct.setType(type);
  acct.setActive(true);
  return runSomeApi(acct);
}
public void test1() {
  Result result = getResult(TypeEnum.Type1);
  assertEquals(name, result.getName());
  assertTrue(result.isActive());
  ResultType[] arr = result.getTypes();
  assertEquals(1, arr.length);
  assertEquals("type1", arr[0].getName());
}

public void test2() {
  Result result = getResult(TypeEnum.Type2);
  assertEquals("test", result.getName());
  assertTrue(result.isActive());
  ResultType[] arr = result.getTypes();
  assertEquals(1, arr.length);
  assertEquals("type2", arr[0].getName());
}
public void testNull(){
  Result result = getResult(null);
  assertEquals(name, result.getName());
  assertTrue(result.isActive());
  ResultType[] arr = result.getTypes();
  assertEquals(2, arr.length);
  assertEquals("type1", arr[0].getName());
  assertEquals("type2", arr[1].getName());
}

private String name = "test";
private getResult(TypeEnum type) {
  Account acct = new Account();
  acct.setName(name);
  acct.setType(type);
  acct.setActive(true);
  return runSomeApi(acct);
}
private void assertInvariants(Result result) {
  assertEquals("test", result.getName());
  assertTrue(result.isActive());
}
private void verifyWhenTypeIsNotNull(String expectedType, TypeEnum type){
  Result result = getResult(type);
  assertInvariants(result);
  ResultType[] arr = result.getTypes();
  assertEquals(1, arr.length);
  assertEquals(expectedType, arr[0].getName());

}
public void test1() {
  verifyWhenTypeIsNotNull("type1" TypeEnum.Type1);
}

public void test2() {
  verifyWhenTypeIsNotNull("type2", TypeEnum.Type2);
}
public void testNull(){
  Result result = getResult(null);
  assertInvariants(result);
  ResultType[] arr = result.getTypes();
  assertEquals(2, arr.length);
  assertEquals("type1", arr[0].getName());
  assertEquals("type2", arr[1].getName());
}

private String name = "test";
private getResult(TypeEnum type) {
  Account acct = new Account();
  acct.setName(name);
  acct.setType(type);
  acct.setActive(true);
  return runSomeApi(acct);
}
private void verify(String[] expectedTypes, TypeEnum type){
  Result result = getResult(type);
  assertEquals("test", result.getName());
  assertTrue(result.isActive());
  ResultType[] arr = result.getTypes();
  assertEquals(expectedTypes.length, arr.length);
  for(int i=0; i<expectedTypes.length; i++) {
    assertEquals(expectedTypes[i], arr[i]);
  }
}
public void test1() {
  verify(new String[]{"type1"} TypeEnum.Type1);
}

public void test2() {
  verify(new String[]{"type2"}, TypeEnum.Type2);
}
public void testNull(){
  verify(new String[]{"type1", "type2"}, null);
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

interface HtmlManipulator {
  String manipulate(String html);
}

class ChangeUserMessageManipulator implements HtmlManipulator {
  public String manipulate(String html) {
    range = find range of element("user message");
    return replaceRangeWith(html, range, "this is the new user message");
  }
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

public static Object newObject(Class interfaceOrDefaultClass, Class[] parameterTypes, Object[] arguments);

ImplFactory.newObject(MyInterface.class, new Class[]{int.class, String.class}, new Object[]{new Integer(1), "abc"});

com.mycompany.MyInterface=com.mycompany.MyInterfaceImpl

public MyInterfaceImpl(int i, String s);

ImplFactory.newObject(DefaultMyInterfaceImpl.class, new Class[]{int.class, String.class}, new Object[]{new Integer(1), "abc"});

MyInterface = serviceFactory.getMyInterface(1, "abc");

public class ImplFactoryProxy {
  private final Map defaults;
  ImplFactoryProxy(Map defaults) {
    this.defaults = defaults;
  }
  ...
}

PropFactory.getInstance().getProperty("property file name").getPropertyValue("key");

IOUtils:
  Properties loadProperties(ClassLoader loader, String resourceName);

new ImplFactoryProxy(PropFactory.getInstance().getProperty("defaults.properties").toProperties())

public class ServiceFactoryUtil {
  public static ServiceFactory getServiceFactory();
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

Plan getPlanByName(String userid, String planName);
Plan[] getPlans(String userid);

select * from Plan where userid=#userid# and plan_name=#planName#
and status=1
order by order_num

select * from Plan where userid=#userid# and status=1

Plan getPlanByName(String userid, String planName){
  Plan[] plans = getPlans(userid);
  for(int i=0; i<plans.length; i++) {
    Plan plan = plans[i];
    if(planName.equals(plan.getPlanName())) {
      return plan;
    }
  }
  return null;
}

select * from v_plans where userid=#userid#
select * from v_plans where userid=#userid# and plan_name=#planName#

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

MyProprietaryConnection conn = ConnectionManager.checkOut(Database.DB_NAME);
try {
  PreparedStatement stmt = conn.getPreparedStatement("some statement id, identifying a sql statement in an xml file");
  stmt.setString(1, "param 1");
  stmt.setInt(2, param2);
  ...
  try {
    ResultSet resultSet = stmt.executeQuery();
    try{
      while(resultSet.next()) {
        ...
      }
    }
    finally {
      resultSet.close();
    }
  }
  finally {
    stmt.close();
  }
}
finally {
  ConnectionManager.checkIn(conn);
}

Object cacheKey = ...;
synchronized(cache) {
  Account acct = (Account)cache.get(cacheKey);
  if(acct == null) {
    acct = runJdbcForAccount(...);
    cache.put(cacheKey, acct);
  }
  return acct.cloneAccount();
}

abstract class PersisterCommand {
  protected abstract void populateStatement(PreparedStatement stmt);
  protected abstract Object processResult(ResultSet resultSet);
  protected abstract boolean isTransactional();
  protected abstract PreparedStatement getStatement();
  public Object run() {
    MyProprietaryConnection conn = ConnectionManager.checkOut(Database.DB_NAME);
    try {
      PreparedStatement stmt = getStatement();
      populateStatement(stmt);
      ...
      try {
        if(isTransactional()) {
          conn.startTransaction();
        }
        ResultSet resultSet = stmt.executeQuery();
        try{
          Object result = processResult(resultSet);
          if(isTransactional()) {
            conn.commitTransaction();
          }
          return result;
        }
        catch(Exception e){
          if(isTransactional()) conn.rollbackTransaction();
          throw e;
        }
        finally {
          resultSet.close();
        }
      }
      finally {
        stmt.close();
      }
    }
    finally {
      ConnectionManager.checkIn(conn);
    }
  }
}

public interface Action {
  Object run(SqlMapSession session);
}
public class IbatisPersistence {
  public SqlMapSession openSession();
  public Object queryForObject(String key);
  public List queryForList(String key);
  public int update(String key, boolean useTransaction);
  public int delete(String key, boolean useTransaction);
  public int update(String key);
  public int delete(String key);
  public Object run(Action action);
}

Accunt acct = persistence.queryForObject("getAccountById", accountId);

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

interface TaxLawBuckets {
  double getRemaining401k();
  double getRemaining403g();
  void apply401k(double amount);
  void apply403g(double amount);
}

interface TaxLawBuckets {
  TaxLawBucket get401k();
  TaxLawBucket get403g();
}
interface TaxLawBucket {
  double getRemaining();
  void apply(double amount);
}

interface TaxLawBuckets {
  private double bucket_401k;
  private double bucket_403g;
  private TaxLawBuckets globalBuckets;

  public double getRemaining401k(){
    return Math.min(bucket_401k, globalBuckets.getRemaining401k());
  }
  public double getRemaining403g() {
    return Math.min(bucket_403g, globalBuckets.getRemaining403g());
  }
  public void apply401k(double amount) {
    bucket_401k -= amount;
    if(bucket_401k<0) throw new SystemException(...);
    globalBuckets.apply401k(amount);
  }
  public void apply403g(double amount) {
    bucket_403g -= amount;
    if(bucket_403g<0) throw new SystemException(...);
    globalBuckets.apply403g(amount);
  }
  //所有其他的函数都直接委托给globalBuckets。
}

public class PerAccountTaxLawBucketsTest extends MockObjectTestCase {
  Mock bucketsMock = mock(TaxLawBuckets.class);
  TaxLawBuckets globalBuckets = bucketMock.proxy();
  PerAccountTaxLawBuckets perAccount = new PerAccountTaxLawBuckets(100, 100, globalBuckets);
  public void testGetRemaining401kReturnsTheMinimal() {
    bucketsMock.expects(once()).method("getRemaining401k").will(return(200));
    assertEquals(100, perAccount.getRemaining401k());
  }
  ...
}

public abstract class AbstractPerAccountTaxLawBucketsTest extends MockObjectTestCase {
  Mock bucketsMock = mock(TaxLawBuckets.class);
  TaxLawBuckets globalBuckets = bucketMock.proxy();
  PerAccountTaxLawBuckets perAccount = new PerAccountTaxLawBuckets(100, 100, globalBuckets);
  public void testGetRemainingReturnsTheMinimal() {
    bucketsMock.expects(once()).method(getRemainingName()).will(return(200));
    assertEquals(100, getRemaining(perAccount));
  }
  ...
  abstract String getRemainingName();
  abstract double getRemaining(TaxLawBuckets buckets);
  abstract String getApplyName();
  abstract void apply(TaxLawBuckets buckets, double amount);
  ...  
}

public class PerAccount401kTestCase extends AbstractPerAccountTaxLawBucketsTest {
  String getRemainingName() {
    return "getRemaining401k";
  }
  double getRemaining(TaxLawBuckets buckets) {
    return buckets.getRemaining401k();
  }
  String getApplyName() {
    return "apply401k";
  }
  void apply(TaxLawBuckets buckets, double amount) {
    buckets.apply401k(amount);
  }
}

public class PerAccount403gTestCase extends AbstractPerAccountTaxLawBucketsTest {
  String getRemainingName() {
    return "getRemaining403g";
  }
  double getRemaining(TaxLawBuckets buckets) {
    return buckets.getRemaining403g();
  }
  String getApplyName() {
    return "apply403g";
  }
  void apply(TaxLawBuckets buckets, double amount) {
    buckets.apply403g(amount);
  }
}

public abstract class AbstractPerAccountTaxLawBucketsTest extends TestCase {
  MockControl bucketsMock = MockControl.createControl(TaxLawBuckets.class);
  TaxLawBuckets globalBuckets = bucketMock.getMock();
  PerAccountTaxLawBuckets perAccount = new PerAccountTaxLawBuckets(100, 100, globalBuckets);
  public void testGetRemainingReturnsTheMinimal() {
    bucketsMock.expectsAndReturn(getRemaining(globalBuckets), 200);
    bucketsMock.replay();
    assertEquals(100, getRemaining(perAccount));
    bucketsMock.verify();
  }
  ...
  abstract double getRemaining(TaxLawBuckets buckets);
  abstract void apply(TaxLawBuckets buckets, double amount);
  ...  
}

public class PerAccount401kTestCase extends AbstractPerAccountTaxLawBucketsTest {
  double getRemaining(TaxLawBuckets buckets) {
    return buckets.getRemaining401k();
  }
  void apply(TaxLawBuckets buckets, double amount) {
    buckets.apply401k(amount);
  }
}

public class PerAccount403gTestCase extends AbstractPerAccountTaxLawBucketsTest {
  double getRemaining(TaxLawBuckets buckets) {
    return buckets.getRemaining403g();
  }
  void apply(TaxLawBuckets buckets, double amount) {
    buckets.apply403g(amount);
  }
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

interface Profile {
  Account getPrimaryAccount();
}
interface Account {
  ...
  Contribution getPreTaxContribution();
}
interface Contribution {
  Balance getBalance();
}

void f(Profile profile, Service service) {
  Account acct = profile.getPrimaryAccount();
  Contribution contrib = acct.getPreTaxContribution();
  Balance balance = contrib.getBalance();
  ...
  if(contrib.isMandatory()){...}
  ...
  service.setContribution(..., contrib);
  ...
  if(balance.isGood()) { ...}
  ...
  service.transferBalance(..., balance);
  ...
}

Contribution contribution(Profile profile) {
  return profile.getPrimaryAccount().getPreTaxContribution();
}
Balance balance(Profile profile) {
  return contribution(profile).getBalance();
}
void f(Profile profile, Service service) {
  ...
  if(contribution(profile).isMandatory()){...}
  ...
  service.setContribution(..., contribution(profile));
  ...
  if(balance(profile).isGood()) { ...}
  ...
  service.transferBalance(..., balance(profile));
  ...
}

private Account[] accts;
Account[] filteredAccounts(String type){
  ArrayList ret = new ArrayList();
  for(...) {
    if(type.equals(accts[i].getType())
      ret.add(accts[i]);
  }
  return ret.toArray(new Account[ret.size()]);
} 
void f(String type) {
  for(int i=0; i<filteredAccounts(type).length; i++){
    if(filteredAccounts(type)[i].getBalance()<0) {
      filteredAccounts(type)[i].setValid(false);
    }
  }
}

void f(String type) {
  Account[] found = filteredAccounts(type);
  for(int i=0; i<found.length; i++){
    if(found[i].getBalance()<0) {
      found[i].setValid(false);
    }
  }
}

private Account acct;
private Contribution contrib;
private Balance balance;
private void cleanStates(){
  acct = null;
  contrib = null;
  balance = null;
}
Account account(Profile profile){
  if(acct==null) acct = profile.getAccount();
  return acct;
}
Contribution contribution(Profile profile) {
  if(contrib==null) contrib = account(profile).getPreTaxContribution();
  return contrib;
}
Balance balance(Profile profile) {
  if(balance==null) balance = contribution(profile).getBalance();
  return balance;
}
void f(Profile profile, Service service) {
  cleanStates();
  ...
}