nus-yam/ex-repair huggingface dataset:
Program: 15064
Project: 15064
Buggy source:
@Override public Set<String> getValues() throws AuthException {
  final Set<String> results=Sets.newHashSet();
  try {
    Transactions.one(ConditionEntity.newInstanceWithId(this.delegate.getConditionId()),new Tx<ConditionEntity>(){
      public void fire(      ConditionEntity t) throws Throwable {
        results.addAll(t.getValues());
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
  return results;
}

Fixed version (ground truth):
@Override public Set<String> getValues() throws AuthException {
  final Set<String> results=Sets.newHashSet();
  try {
    Transactions.one(ConditionEntity.newInstanceWithId(this.delegate.getConditionId()),new Tx<ConditionEntity>(){
      public void fire(      ConditionEntity t){
        results.addAll(t.getValues());
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
  return results;
}
Program: 15065
Project: 15065
Buggy source:
public void fire(ConditionEntity t) throws Throwable {
  sb.append(t.toString());
}

Fixed version (ground truth):
public void fire(ConditionEntity t){
  sb.append(t.toString());
}
Program: 15066
Project: 15066
Buggy source:
@Override public String toString(){
  final StringBuilder sb=new StringBuilder();
  try {
    Transactions.one(ConditionEntity.newInstanceWithId(this.delegate.getConditionId()),new Tx<ConditionEntity>(){
      public void fire(      ConditionEntity t) throws Throwable {
        sb.append(t.toString());
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
  }
  return sb.toString();
}

Fixed version (ground truth):
@Override public String toString(){
  final StringBuilder sb=new StringBuilder();
  try {
    Transactions.one(ConditionEntity.newInstanceWithId(this.delegate.getConditionId()),new Tx<ConditionEntity>(){
      public void fire(      ConditionEntity t){
        sb.append(t.toString());
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
  }
  return sb.toString();
}
Program: 15067
Project: 15067
Buggy source:
@Override public void setName(final String name) throws AuthException {
  try {
    this.getAccount().lookupGroupByName(name);
  }
 catch (  AuthException ae) {
    try {
      Transactions.one(GroupEntity.newInstanceWithGroupId(this.delegate.getGroupId()),new Tx<GroupEntity>(){
        public void fire(        GroupEntity t) throws Throwable {
          t.setName(name);
        }
      }
);
    }
 catch (    ExecutionException e) {
      Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
      throw new AuthException(e);
    }
    return;
  }
  throw new AuthException("String_Node_Str" + name);
}

Fixed version (ground truth):
@Override public void setName(final String name) throws AuthException {
  try {
    this.getAccount().lookupGroupByName(name);
  }
 catch (  AuthException ae) {
    try {
      Transactions.one(GroupEntity.newInstanceWithGroupId(this.delegate.getGroupId()),new Tx<GroupEntity>(){
        public void fire(        GroupEntity t){
          t.setName(name);
        }
      }
);
    }
 catch (    ExecutionException e) {
      Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
      throw new AuthException(e);
    }
    return;
  }
  throw new AuthException("String_Node_Str" + name);
}
Program: 15068
Project: 15068
Buggy source:
@Override public void setPath(final String path) throws AuthException {
  try {
    Transactions.one(GroupEntity.newInstanceWithGroupId(this.delegate.getGroupId()),new Tx<GroupEntity>(){
      public void fire(      GroupEntity t) throws Throwable {
        t.setPath(path);
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
}

Fixed version (ground truth):
@Override public void setPath(final String path) throws AuthException {
  try {
    Transactions.one(GroupEntity.newInstanceWithGroupId(this.delegate.getGroupId()),new Tx<GroupEntity>(){
      public void fire(      GroupEntity t){
        t.setPath(path);
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
}
Program: 15069
Project: 15069
Buggy source:
@Override public List<Policy> getPolicies(){
  final List<Policy> results=Lists.newArrayList();
  try {
    Transactions.one(GroupEntity.newInstanceWithGroupId(this.delegate.getGroupId()),new Tx<GroupEntity>(){
      public void fire(      GroupEntity t) throws Throwable {
        for (        PolicyEntity p : t.getPolicies()) {
          results.add(new DatabasePolicyProxy(p));
        }
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
  }
  return results;
}

Fixed version (ground truth):
@Override public List<Policy> getPolicies(){
  final List<Policy> results=Lists.newArrayList();
  try {
    Transactions.one(GroupEntity.newInstanceWithGroupId(this.delegate.getGroupId()),new Tx<GroupEntity>(){
      public void fire(      GroupEntity t){
        for (        PolicyEntity p : t.getPolicies()) {
          results.add(new DatabasePolicyProxy(p));
        }
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
  }
  return results;
}
Program: 15070
Project: 15070
Buggy source:
@Override public List<User> getUsers(){
  final List<User> results=Lists.newArrayList();
  try {
    Transactions.one(GroupEntity.newInstanceWithGroupId(this.delegate.getGroupId()),new Tx<GroupEntity>(){
      public void fire(      GroupEntity t) throws Throwable {
        for (        UserEntity u : t.getUsers()) {
          results.add(new DatabaseUserProxy(u));
        }
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
  }
  return results;
}

Fixed version (ground truth):
@Override public List<User> getUsers(){
  final List<User> results=Lists.newArrayList();
  try {
    Transactions.one(GroupEntity.newInstanceWithGroupId(this.delegate.getGroupId()),new Tx<GroupEntity>(){
      public void fire(      GroupEntity t){
        for (        UserEntity u : t.getUsers()) {
          results.add(new DatabaseUserProxy(u));
        }
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
  }
  return results;
}
Program: 15071
Project: 15071
Buggy source:
@Override public Account getAccount(){
  final List<DatabaseAccountProxy> results=Lists.newArrayList();
  try {
    Transactions.one(GroupEntity.newInstanceWithGroupId(this.delegate.getGroupId()),new Tx<GroupEntity>(){
      public void fire(      GroupEntity t) throws Throwable {
        results.add(new DatabaseAccountProxy((AccountEntity)t.getAccount()));
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
  }
  return results.get(0);
}

Fixed version (ground truth):
@Override public Account getAccount(){
  final List<DatabaseAccountProxy> results=Lists.newArrayList();
  try {
    Transactions.one(GroupEntity.newInstanceWithGroupId(this.delegate.getGroupId()),new Tx<GroupEntity>(){
      public void fire(      GroupEntity t){
        results.add(new DatabaseAccountProxy((AccountEntity)t.getAccount()));
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
  }
  return results.get(0);
}
Program: 15072
Project: 15072
Buggy source:
@Override public void setUserGroup(final Boolean userGroup) throws AuthException {
  try {
    Transactions.one(GroupEntity.newInstanceWithGroupId(this.delegate.getGroupId()),new Tx<GroupEntity>(){
      public void fire(      GroupEntity t) throws Throwable {
        t.setUserGroup(userGroup);
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
}

Fixed version (ground truth):
@Override public void setUserGroup(final Boolean userGroup) throws AuthException {
  try {
    Transactions.one(GroupEntity.newInstanceWithGroupId(this.delegate.getGroupId()),new Tx<GroupEntity>(){
      public void fire(      GroupEntity t){
        t.setUserGroup(userGroup);
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
}
Program: 15073
Project: 15073
Buggy source:
public void fire(GroupEntity t) throws Throwable {
  results.add(new DatabaseAccountProxy((AccountEntity)t.getAccount()));
}

Fixed version (ground truth):
public void fire(GroupEntity t){
  results.add(new DatabaseAccountProxy((AccountEntity)t.getAccount()));
}
Program: 15074
Project: 15074
Buggy source:
@Override public String toString(){
  final StringBuilder sb=new StringBuilder();
  try {
    Transactions.one(GroupEntity.newInstanceWithGroupId(this.delegate.getGroupId()),new Tx<GroupEntity>(){
      public void fire(      GroupEntity t) throws Throwable {
        sb.append(t.toString());
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
  }
  return sb.toString();
}

Fixed version (ground truth):
@Override public String toString(){
  final StringBuilder sb=new StringBuilder();
  try {
    Transactions.one(GroupEntity.newInstanceWithGroupId(this.delegate.getGroupId()),new Tx<GroupEntity>(){
      public void fire(      GroupEntity t){
        sb.append(t.toString());
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
  }
  return sb.toString();
}
Program: 15075
Project: 15075
Buggy source:
@Override public Group getGroup() throws AuthException {
  final List<Group> results=Lists.newArrayList();
  try {
    Transactions.one(PolicyEntity.newInstanceWithId(this.delegate.getPolicyId()),new Tx<PolicyEntity>(){
      public void fire(      PolicyEntity t) throws Throwable {
        results.add(new DatabaseGroupProxy(t.getGroup()));
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
  return results.get(0);
}

Fixed version (ground truth):
@Override public Group getGroup() throws AuthException {
  final List<Group> results=Lists.newArrayList();
  try {
    Transactions.one(PolicyEntity.newInstanceWithId(this.delegate.getPolicyId()),new Tx<PolicyEntity>(){
      public void fire(      PolicyEntity t){
        results.add(new DatabaseGroupProxy(t.getGroup()));
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
  return results.get(0);
}
Program: 15076
Project: 15076
Buggy source:
public void fire(PolicyEntity t) throws Throwable {
  results.add(new DatabaseGroupProxy(t.getGroup()));
}

Fixed version (ground truth):
public void fire(PolicyEntity t){
  results.add(new DatabaseGroupProxy(t.getGroup()));
}
Program: 15077
Project: 15077
Buggy source:
@Override public void setPassword(final String password) throws AuthException {
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t) throws Throwable {
        t.setPassword(password);
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
}

Fixed version (ground truth):
@Override public void setPassword(final String password) throws AuthException {
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t){
        t.setPassword(password);
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
}
Program: 15078
Project: 15078
Buggy source:
@Override public List<Certificate> getCertificates() throws AuthException {
  final List<Certificate> results=Lists.newArrayList();
  try {
    final UserEntity search=UserEntity.newInstanceWithUserId(this.delegate.getUserId());
    Transactions.one(search,new Tx<UserEntity>(){
      public void fire(      UserEntity t) throws Throwable {
        for (        CertificateEntity c : t.getCertificates()) {
          results.add(new DatabaseCertificateProxy(c));
        }
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
  return results;
}

Fixed version (ground truth):
@Override public List<Certificate> getCertificates() throws AuthException {
  final List<Certificate> results=Lists.newArrayList();
  try {
    final UserEntity search=UserEntity.newInstanceWithUserId(this.delegate.getUserId());
    Transactions.one(search,new Tx<UserEntity>(){
      public void fire(      UserEntity t){
        for (        CertificateEntity c : t.getCertificates()) {
          results.add(new DatabaseCertificateProxy(c));
        }
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
  return results;
}
Program: 15079
Project: 15079
Buggy source:
@Override public Account getAccount() throws AuthException {
  final List<Account> results=Lists.newArrayList();
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t) throws Throwable {
        if (t.getGroups().size() < 1) {
          throw new RuntimeException("String_Node_Str");
        }
        results.add(new DatabaseAccountProxy(t.getGroups().get(0).getAccount()));
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
  return results.get(0);
}

Fixed version (ground truth):
@Override public Account getAccount() throws AuthException {
  final List<Account> results=Lists.newArrayList();
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t){
        if (t.getGroups().size() < 1) {
          throw new RuntimeException("String_Node_Str");
        }
        results.add(new DatabaseAccountProxy(t.getGroups().get(0).getAccount()));
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
  return results.get(0);
}
Program: 15080
Project: 15080
Buggy source:
public void fire(UserEntity t) throws Throwable {
  if (t.getGroups().size() < 1) {
    throw new RuntimeException("String_Node_Str");
  }
  results.add(new DatabaseAccountProxy(t.getGroups().get(0).getAccount()));
}

Fixed version (ground truth):
public void fire(UserEntity t){
  if (t.getGroups().size() < 1) {
    throw new RuntimeException("String_Node_Str");
  }
  results.add(new DatabaseAccountProxy(t.getGroups().get(0).getAccount()));
}
Program: 15081
Project: 15081
Buggy source:
@Override public void setRegistrationStatus(final RegistrationStatus stat) throws AuthException {
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t) throws Throwable {
        t.setRegistrationStatus(stat);
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
}

Fixed version (ground truth):
@Override public void setRegistrationStatus(final RegistrationStatus stat) throws AuthException {
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t){
        t.setRegistrationStatus(stat);
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
}
Program: 15082
Project: 15082
Buggy source:
@Override public void setConfirmationCode(final String code) throws AuthException {
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t) throws Throwable {
        t.setConfirmationCode(code);
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
}

Fixed version (ground truth):
@Override public void setConfirmationCode(final String code) throws AuthException {
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t){
        t.setConfirmationCode(code);
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
}
Program: 15083
Project: 15083
Buggy source:
@Override public List<Group> getGroups() throws AuthException {
  final List<Group> results=Lists.newArrayList();
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t) throws Throwable {
        for (        GroupEntity g : t.getGroups()) {
          results.add(new DatabaseGroupProxy(g));
        }
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
  return results;
}

Fixed version (ground truth):
@Override public List<Group> getGroups() throws AuthException {
  final List<Group> results=Lists.newArrayList();
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t){
        for (        GroupEntity g : t.getGroups()) {
          results.add(new DatabaseGroupProxy(g));
        }
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
  return results;
}
Program: 15084
Project: 15084
Buggy source:
@Override public Map<String,String> getInfo() throws AuthException {
  final Map<String,String> results=Maps.newHashMap();
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t) throws Throwable {
        results.putAll(t.getInfo());
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
  return results;
}

Fixed version (ground truth):
@Override public Map<String,String> getInfo() throws AuthException {
  final Map<String,String> results=Maps.newHashMap();
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t){
        results.putAll(t.getInfo());
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
  return results;
}
Program: 15085
Project: 15085
Buggy source:
@Override public void setPath(final String path) throws AuthException {
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t) throws Throwable {
        t.setPath(path);
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
}

Fixed version (ground truth):
@Override public void setPath(final String path) throws AuthException {
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t){
        t.setPath(path);
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
}
Program: 15086
Project: 15086
Buggy source:
@Override public List<AccessKey> getKeys() throws AuthException {
  final List<AccessKey> results=Lists.newArrayList();
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t) throws Throwable {
        for (        AccessKeyEntity k : t.getKeys()) {
          results.add(new DatabaseAccessKeyProxy(k));
        }
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
  return results;
}

Fixed version (ground truth):
@Override public List<AccessKey> getKeys() throws AuthException {
  final List<AccessKey> results=Lists.newArrayList();
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t){
        for (        AccessKeyEntity k : t.getKeys()) {
          results.add(new DatabaseAccessKeyProxy(k));
        }
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
  return results;
}
Program: 15087
Project: 15087
Buggy source:
@Override public void setEnabled(final Boolean enabled) throws AuthException {
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t) throws Throwable {
        t.setEnabled(enabled);
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
}

Fixed version (ground truth):
@Override public void setEnabled(final Boolean enabled) throws AuthException {
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t){
        t.setEnabled(enabled);
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
}
Program: 15088
Project: 15088
Buggy source:
@Override public void setToken(final String token) throws AuthException {
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t) throws Throwable {
        t.setToken(token);
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
}

Fixed version (ground truth):
@Override public void setToken(final String token) throws AuthException {
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t){
        t.setToken(token);
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
}
Program: 15089
Project: 15089
Buggy source:
@Override public void setPasswordExpires(final Long time) throws AuthException {
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t) throws Throwable {
        t.setPasswordExpires(time);
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
}

Fixed version (ground truth):
@Override public void setPasswordExpires(final Long time) throws AuthException {
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t){
        t.setPasswordExpires(time);
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
}
Program: 15090
Project: 15090
Buggy source:
@Override public String toString(){
  final StringBuilder sb=new StringBuilder();
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t) throws Throwable {
        sb.append(t.toString());
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
  }
  return sb.toString();
}

Fixed version (ground truth):
@Override public String toString(){
  final StringBuilder sb=new StringBuilder();
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t){
        sb.append(t.toString());
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
  }
  return sb.toString();
}
Program: 15091
Project: 15091
Buggy source:
@Override public void setInfo(final Map<String,String> newInfo) throws AuthException {
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t) throws Throwable {
        t.getInfo().clear();
        t.getInfo().putAll(newInfo);
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
}

Fixed version (ground truth):
@Override public void setInfo(final Map<String,String> newInfo) throws AuthException {
  try {
    Transactions.one(UserEntity.newInstanceWithUserId(this.delegate.getUserId()),new Tx<UserEntity>(){
      public void fire(      UserEntity t){
        t.getInfo().clear();
        t.getInfo().putAll(newInfo);
      }
    }
);
  }
 catch (  ExecutionException e) {
    Debugging.logError(LOG,e,"String_Node_Str" + this.delegate);
    throw new AuthException(e);
  }
}
Program: 15094
Project: 15094
Buggy source:
public static void deleteUsers(User requestUser,ArrayList<String> ids) throws EucalyptusServiceException {
  boolean hasError=false;
  for (  String id : ids) {
    try {
      User user=Accounts.lookupUserById(id);
      if (!user.isSystemAdmin()) {
        Account account=user.getAccount();
        EuarePermission.authorizeDeleteUser(requestUser,account,user);
        account.deleteUser(user.getName(),false,true);
      }
 else {
        throw new IllegalArgumentException("String_Node_Str");
      }
    }
 catch (    Exception e) {
      LOG.error("String_Node_Str" + id,e);
      LOG.debug(e,e);
      hasError=true;
    }
  }
  if (hasError) {
    throw new EucalyptusServiceException("String_Node_Str");
  }
}

Fixed version (ground truth):
public static void deleteUsers(User requestUser,ArrayList<String> ids) throws EucalyptusServiceException {
  boolean hasError=false;
  for (  String id : ids) {
    try {
      User user=Accounts.lookupUserById(id);
      if (!(user.isSystemAdmin() && user.isAccountAdmin())) {
        Account account=user.getAccount();
        EuarePermission.authorizeDeleteUser(requestUser,account,user);
        account.deleteUser(user.getName(),false,true);
      }
 else {
        throw new IllegalArgumentException("String_Node_Str");
      }
    }
 catch (    Exception e) {
      LOG.error("String_Node_Str" + id,e);
      LOG.debug(e,e);
      hasError=true;
    }
  }
  if (hasError) {
    throw new EucalyptusServiceException("String_Node_Str");
  }
}
Program: 15098
Project: 15098
Buggy source:
public static void deleteUsers(User requestUser,ArrayList<String> ids) throws EucalyptusServiceException {
  boolean hasError=false;
  for (  String id : ids) {
    try {
      User user=Accounts.lookupUserById(id);
      if (!user.isSystemAdmin()) {
        Account account=user.getAccount();
        EuarePermission.authorizeDeleteUser(requestUser,account,user);
        account.deleteUser(user.getName(),false,true);
      }
 else {
        throw new IllegalArgumentException("String_Node_Str");
      }
    }
 catch (    Exception e) {
      LOG.error("String_Node_Str" + id,e);
      LOG.debug(e,e);
      hasError=true;
    }
  }
  if (hasError) {
    throw new EucalyptusServiceException("String_Node_Str");
  }
}

Fixed version (ground truth):
public static void deleteUsers(User requestUser,ArrayList<String> ids) throws EucalyptusServiceException {
  boolean hasError=false;
  for (  String id : ids) {
    try {
      User user=Accounts.lookupUserById(id);
      if (!(user.isSystemAdmin() && user.isAccountAdmin())) {
        Account account=user.getAccount();
        EuarePermission.authorizeDeleteUser(requestUser,account,user);
        account.deleteUser(user.getName(),false,true);
      }
 else {
        throw new IllegalArgumentException("String_Node_Str");
      }
    }
 catch (    Exception e) {
      LOG.error("String_Node_Str" + id,e);
      LOG.debug(e,e);
      hasError=true;
    }
  }
  if (hasError) {
    throw new EucalyptusServiceException("String_Node_Str");
  }
}
Program: 15100
Project: 15100
Buggy source:
@Override public void fireEvent(Event event){
  if (event instanceof ClockTick) {
    for (    TxHandle tx : TxHandle.outstanding.values()) {
      if (tx.isExpired()) {
        LOG.error("String_Node_Str" + tx);
        LOG.error(tx.owner,tx.owner);
      }
    }
  }
}

Fixed version (ground truth):
@Override public void fireEvent(Event event){
  if (event instanceof ClockTick) {
    for (    TxHandle tx : TxHandle.outstanding.values()) {
      if (tx.isExpired()) {
        LOG.error("String_Node_Str" + tx);
        LOG.error(tx.owner);
      }
    }
  }
}
Program: 15101
Project: 15101
Buggy source:
public TxHandle(String ctx){
  this.txUuid=String.format("String_Node_Str",ctx,UUID.randomUUID().toString());
  this.owner=new Exception();
  this.startTime=Calendar.getInstance();
  this.stopWatch=new StopWatch();
  this.stopWatch.start();
  EntityManagerFactory anemf=(EntityManagerFactoryImpl)PersistenceContexts.getEntityManagerFactory(ctx);
  Assertions.assertNotNull(anemf,"String_Node_Str" + ctx);
  try {
    this.em=anemf.createEntityManager();
    Assertions.assertNotNull(this.em,"String_Node_Str" + ctx);
    this.delegate=this.em.getTransaction();
    this.delegate.begin();
    this.session=new WeakReference<Session>((Session)this.em.getDelegate());
  }
 catch (  Throwable e) {
    this.rollback();
    LOG.error(e,e);
    throw new RuntimeException(e);
  }
 finally {
    outstanding.put(this.txUuid,this);
  }
}

Fixed version (ground truth):
public TxHandle(String ctx){
  this.txUuid=String.format("String_Node_Str",ctx,UUID.randomUUID().toString());
  this.owner=Joiner.on("String_Node_Str").join(Thread.currentThread().getStackTrace());
  this.startTime=Calendar.getInstance();
  this.stopWatch=new StopWatch();
  this.stopWatch.start();
  EntityManagerFactory anemf=(EntityManagerFactoryImpl)PersistenceContexts.getEntityManagerFactory(ctx);
  Assertions.assertNotNull(anemf,"String_Node_Str" + ctx);
  try {
    this.em=anemf.createEntityManager();
    Assertions.assertNotNull(this.em,"String_Node_Str" + ctx);
    this.delegate=this.em.getTransaction();
    this.delegate.begin();
    this.session=new WeakReference<Session>((Session)this.em.getDelegate());
  }
 catch (  Throwable e) {
    this.rollback();
    LOG.error(e,e);
    throw new RuntimeException(e);
  }
 finally {
    outstanding.put(this.txUuid,this);
  }
}
Program: 15102
Project: 15102
Buggy source:
@Override public String toString(){
  return String.format("String_Node_Str",this.txUuid,this.startTime,this.splitTime);
}

Fixed version (ground truth):
@Override public String toString(){
  return String.format("String_Node_Str",this.txUuid,this.startTime.getTime(),this.splitTime,Logs.EXTREME ? this.owner : "String_Node_Str");
}
Program: 15103
Project: 15103
Buggy source:
@Override public String getValue(){
  if (Bootstrap.isFinished()) {
    try {
      String dbValue=StaticDatabasePropertyEntry.lookup(this.getFieldCanonicalName(),this.getQualifiedName(),this.safeGetFieldValue()).getValue();
      this.field.set(null,dbValue);
      return dbValue;
    }
 catch (    Exception e) {
      LOG.warn("String_Node_Str" + super.getQualifiedName() + "String_Node_Str"+ e.getMessage());
      Logs.extreme().debug(e,e);
      return super.getDefaultValue();
    }
  }
 else {
    return super.getDefaultValue();
  }
}

Fixed version (ground truth):
@Override public String getValue(){
  if (Bootstrap.isFinished()) {
    try {
      String dbValue=StaticDatabasePropertyEntry.lookup(this.getFieldCanonicalName(),this.getQualifiedName(),this.safeGetFieldValue()).getValue();
      Object o=super.getTypeParser().parse(dbValue);
      this.field.set(null,o);
      return dbValue;
    }
 catch (    Exception e) {
      LOG.warn("String_Node_Str" + super.getQualifiedName() + "String_Node_Str"+ e.getMessage());
      Logs.extreme().debug(e,e);
      return super.getDefaultValue();
    }
  }
 else {
    return super.getDefaultValue();
  }
}
Program: 15104
Project: 15104
Buggy source:
static StaticDatabasePropertyEntry lookup(String fieldName,String propName,String defaultFieldValue) throws Exception {
  EntityWrapper<StaticDatabasePropertyEntry> db=EntityWrapper.get(StaticDatabasePropertyEntry.class);
  try {
    StaticDatabasePropertyEntry dbEntry=db.getUnique(new StaticDatabasePropertyEntry(fieldName,propName,null));
    db.commit();
    return dbEntry;
  }
 catch (  Exception ex) {
    StaticDatabasePropertyEntry dbEntry;
    try {
      dbEntry=new StaticDatabasePropertyEntry(fieldName,propName,defaultFieldValue);
      db.persist(dbEntry);
      db.commit();
      return dbEntry;
    }
 catch (    Exception ex1) {
      db.rollback();
      throw ex1;
    }
  }
}

Fixed version (ground truth):
static StaticDatabasePropertyEntry lookup(String fieldName,String propName,String defaultFieldValue) throws Exception {
  EntityWrapper<StaticDatabasePropertyEntry> db=EntityWrapper.get(StaticDatabasePropertyEntry.class);
  try {
    StaticDatabasePropertyEntry dbEntry=db.getUnique(new StaticDatabasePropertyEntry(fieldName,propName,null));
    db.commit();
    return dbEntry;
  }
 catch (  Exception ex) {
    StaticDatabasePropertyEntry dbEntry;
    try {
      dbEntry=new StaticDatabasePropertyEntry(fieldName,propName,defaultFieldValue);
      db.persist(dbEntry);
      db.commit();
      return dbEntry;
    }
 catch (    Exception ex1) {
      Logs.extreme().error("String_Node_Str" + fieldName + "String_Node_Str"+ propName);
      db.rollback();
      throw ex1;
    }
  }
}
Program: 15105
Project: 15105
Buggy source:
static StaticDatabasePropertyEntry lookup(String fieldName,String propName,String defaultFieldValue) throws Exception {
  EntityWrapper<StaticDatabasePropertyEntry> db=EntityWrapper.get(StaticDatabasePropertyEntry.class);
  try {
    StaticDatabasePropertyEntry dbEntry=db.getUnique(new StaticDatabasePropertyEntry(fieldName,propName,null));
    db.commit();
    return dbEntry;
  }
 catch (  EucalyptusCloudException ex) {
    StaticDatabasePropertyEntry dbEntry;
    try {
      dbEntry=new StaticDatabasePropertyEntry(fieldName,propName,defaultFieldValue);
      db.persist(dbEntry);
      db.commit();
      return dbEntry;
    }
 catch (    Exception ex1) {
      db.rollback();
      throw ex1;
    }
  }
}

Fixed version (ground truth):
static StaticDatabasePropertyEntry lookup(String fieldName,String propName,String defaultFieldValue) throws Exception {
  EntityWrapper<StaticDatabasePropertyEntry> db=EntityWrapper.get(StaticDatabasePropertyEntry.class);
  try {
    StaticDatabasePropertyEntry dbEntry=db.getUnique(new StaticDatabasePropertyEntry(fieldName,propName,null));
    db.commit();
    return dbEntry;
  }
 catch (  Exception ex) {
    StaticDatabasePropertyEntry dbEntry;
    try {
      dbEntry=new StaticDatabasePropertyEntry(fieldName,propName,defaultFieldValue);
      db.persist(dbEntry);
      db.commit();
      return dbEntry;
    }
 catch (    Exception ex1) {
      db.rollback();
      throw ex1;
    }
  }
}
Program: 15106
Project: 15106
Buggy source:
static StaticDatabasePropertyEntry update(String fieldName,String propName,String newFieldValue) throws Exception {
  EntityWrapper<StaticDatabasePropertyEntry> db=EntityWrapper.get(StaticDatabasePropertyEntry.class);
  try {
    StaticDatabasePropertyEntry dbEntry=db.getUnique(new StaticDatabasePropertyEntry(fieldName,propName,null));
    dbEntry.setValue(newFieldValue);
    db.commit();
    return dbEntry;
  }
 catch (  EucalyptusCloudException ex) {
    StaticDatabasePropertyEntry dbEntry;
    try {
      dbEntry=new StaticDatabasePropertyEntry(fieldName,propName,newFieldValue);
      db.persist(dbEntry);
      db.commit();
    }
 catch (    Exception ex1) {
      throw ex1;
    }
    return dbEntry;
  }
}

Fixed version (ground truth):
static StaticDatabasePropertyEntry update(String fieldName,String propName,String newFieldValue) throws Exception {
  EntityWrapper<StaticDatabasePropertyEntry> db=EntityWrapper.get(StaticDatabasePropertyEntry.class);
  try {
    StaticDatabasePropertyEntry dbEntry=db.getUnique(new StaticDatabasePropertyEntry(fieldName,propName,null));
    dbEntry.setValue(newFieldValue);
    db.commit();
    return dbEntry;
  }
 catch (  Exception ex) {
    StaticDatabasePropertyEntry dbEntry;
    try {
      dbEntry=new StaticDatabasePropertyEntry(fieldName,propName,newFieldValue);
      db.persist(dbEntry);
      db.commit();
    }
 catch (    Exception ex1) {
      throw ex1;
    }
    return dbEntry;
  }
}
Program: 15107
Project: 15107
Buggy source:
static StaticDatabasePropertyEntry lookup(String fieldName,String propName,String defaultFieldValue){
  EntityWrapper<StaticDatabasePropertyEntry> db=EntityWrapper.get(StaticDatabasePropertyEntry.class);
  try {
    StaticDatabasePropertyEntry dbEntry=db.getUnique(new StaticDatabasePropertyEntry(fieldName,propName,null));
    db.rollback();
    return dbEntry;
  }
 catch (  EucalyptusCloudException ex) {
    StaticDatabasePropertyEntry dbEntry=new StaticDatabasePropertyEntry(fieldName,propName,defaultFieldValue);
    db.persist(dbEntry);
    db.commit();
    return dbEntry;
  }
}

Fixed version (ground truth):
static StaticDatabasePropertyEntry lookup(String fieldName,String propName,String defaultFieldValue) throws Exception {
  EntityWrapper<StaticDatabasePropertyEntry> db=EntityWrapper.get(StaticDatabasePropertyEntry.class);
  try {
    StaticDatabasePropertyEntry dbEntry=db.getUnique(new StaticDatabasePropertyEntry(fieldName,propName,null));
    db.commit();
    return dbEntry;
  }
 catch (  EucalyptusCloudException ex) {
    StaticDatabasePropertyEntry dbEntry;
    try {
      dbEntry=new StaticDatabasePropertyEntry(fieldName,propName,defaultFieldValue);
      db.persist(dbEntry);
      db.commit();
      return dbEntry;
    }
 catch (    Exception ex1) {
      db.rollback();
      throw ex1;
    }
  }
}
Program: 15108
Project: 15108
Buggy source:
static StaticDatabasePropertyEntry update(String fieldName,String propName,String newFieldValue){
  EntityWrapper<StaticDatabasePropertyEntry> db=EntityWrapper.get(StaticDatabasePropertyEntry.class);
  try {
    StaticDatabasePropertyEntry dbEntry=db.getUnique(new StaticDatabasePropertyEntry(fieldName,propName,null));
    dbEntry.setValue(newFieldValue);
    db.commit();
    return dbEntry;
  }
 catch (  EucalyptusCloudException ex) {
    StaticDatabasePropertyEntry dbEntry=new StaticDatabasePropertyEntry(fieldName,propName,newFieldValue);
    db.persist(dbEntry);
    db.commit();
    return dbEntry;
  }
}

Fixed version (ground truth):
static StaticDatabasePropertyEntry update(String fieldName,String propName,String newFieldValue) throws Exception {
  EntityWrapper<StaticDatabasePropertyEntry> db=EntityWrapper.get(StaticDatabasePropertyEntry.class);
  try {
    StaticDatabasePropertyEntry dbEntry=db.getUnique(new StaticDatabasePropertyEntry(fieldName,propName,null));
    dbEntry.setValue(newFieldValue);
    db.commit();
    return dbEntry;
  }
 catch (  EucalyptusCloudException ex) {
    StaticDatabasePropertyEntry dbEntry;
    try {
      dbEntry=new StaticDatabasePropertyEntry(fieldName,propName,newFieldValue);
      db.persist(dbEntry);
      db.commit();
    }
 catch (    Exception ex1) {
      throw ex1;
    }
    return dbEntry;
  }
}
Program: 15109
Project: 15109
Buggy source:
@Override public String getValue(){
  if (Bootstrap.isFinished()) {
    try {
      return StaticDatabasePropertyEntry.lookup(this.getFieldCanonicalName(),this.getQualifiedName(),this.getDefaultValue()).getValue();
    }
 catch (    Exception e) {
      LOG.debug(e,e);
      return super.getDefaultValue();
    }
  }
 else {
    return super.getDefaultValue();
  }
}

Fixed version (ground truth):
@Override public String getValue(){
  if (Bootstrap.isFinished()) {
    try {
      String dbValue=StaticDatabasePropertyEntry.lookup(this.getFieldCanonicalName(),this.getQualifiedName(),this.safeGetFieldValue()).getValue();
      this.field.set(null,dbValue);
      return dbValue;
    }
 catch (    Exception e) {
      LOG.warn("String_Node_Str" + super.getQualifiedName() + "String_Node_Str"+ e.getMessage());
      Logs.extreme().debug(e,e);
      return super.getDefaultValue();
    }
  }
 else {
    return super.getDefaultValue();
  }
}
Program: 15110
Project: 15110
Buggy source:
@Override public String setValue(String s){
  if (Bootstrap.isFinished()) {
    try {
      Object o=super.getTypeParser().parse(s);
      this.fireChange(s);
      StaticDatabasePropertyEntry.lookup(this.getFieldCanonicalName(),this.getQualifiedName(),s);
      this.field.set(null,o);
      LOG.info("String_Node_Str" + super.getQualifiedName() + "String_Node_Str"+ s);
    }
 catch (    Throwable t) {
      LOG.warn("String_Node_Str" + super.getQualifiedName() + "String_Node_Str"+ t.getMessage());
      LOG.debug(t,t);
    }
    return this.getValue();
  }
 else {
    return super.getDefaultValue();
  }
}

Fixed version (ground truth):
@Override public String setValue(String s){
  if (Bootstrap.isFinished()) {
    try {
      Object o=super.getTypeParser().parse(s);
      this.fireChange(s);
      StaticDatabasePropertyEntry.update(this.getFieldCanonicalName(),this.getQualifiedName(),s);
      this.field.set(null,o);
      LOG.info("String_Node_Str" + super.getQualifiedName() + "String_Node_Str"+ s);
    }
 catch (    Exception e) {
      LOG.warn("String_Node_Str" + super.getQualifiedName() + "String_Node_Str"+ e.getMessage());
      Logs.extreme().debug(e,e);
    }
    return this.getValue();
  }
 else {
    return super.getDefaultValue();
  }
}
Program: 15111
Project: 15111
Buggy source:
private void doCreateUsers(final String names,final String path){
  if (currentSelected == null || currentSelected.size() != 1) {
    return;
  }
  final String accountId=this.currentSelected.toArray(new SearchResultRow[0])[0].getField(0);
  this.clientFactory.getShellView().getFooterView().showStatus(StatusType.LOADING,"String_Node_Str" + names + "String_Node_Str",0);
  this.clientFactory.getBackendService().createUsers(this.clientFactory.getLocalSession().getSession(),accountId,names,path,new AsyncCallback<ArrayList<String>>(){
    @Override public void onFailure(    Throwable caught){
      clientFactory.getShellView().getFooterView().showStatus(StatusType.ERROR,"String_Node_Str",FooterView.DEFAULT_STATUS_CLEAR_DELAY);
      clientFactory.getShellView().getLogView().log(LogType.ERROR,"String_Node_Str" + names + "String_Node_Str"+ accountId+ "String_Node_Str"+ caught.getMessage());
    }
    @Override public void onSuccess(    ArrayList<String> created){
      clientFactory.getShellView().getFooterView().showStatus(StatusType.NONE,created.size() + "String_Node_Str",FooterView.DEFAULT_STATUS_CLEAR_DELAY);
      clientFactory.getShellView().getLogView().log(LogType.INFO,"String_Node_Str" + created + "String_Node_Str"+ accountId);
    }
  }
);
}

Fixed version (ground truth):
private void doCreateUsers(final String names,final String path){
  if (currentSelected == null || currentSelected.size() != 1) {
    return;
  }
  final String accountId=this.currentSelected.toArray(new SearchResultRow[0])[0].getField(0);
  this.clientFactory.getShellView().getFooterView().showStatus(StatusType.LOADING,"String_Node_Str" + names + "String_Node_Str",0);
  this.clientFactory.getBackendService().createUsers(this.clientFactory.getLocalSession().getSession(),accountId,names,path,new AsyncCallback<ArrayList<String>>(){
    @Override public void onFailure(    Throwable caught){
      clientFactory.getShellView().getFooterView().showStatus(StatusType.ERROR,"String_Node_Str",FooterView.DEFAULT_STATUS_CLEAR_DELAY);
      clientFactory.getShellView().getLogView().log(LogType.ERROR,"String_Node_Str" + names + "String_Node_Str"+ accountId+ "String_Node_Str"+ caught.getMessage());
    }
    @Override public void onSuccess(    ArrayList<String> created){
      if (created == null || created.size() < 1) {
        clientFactory.getShellView().getFooterView().showStatus(StatusType.ERROR,"String_Node_Str",FooterView.DEFAULT_STATUS_CLEAR_DELAY);
        clientFactory.getShellView().getLogView().log(LogType.ERROR,"String_Node_Str" + names + "String_Node_Str"+ accountId+ "String_Node_Str");
      }
 else {
        clientFactory.getShellView().getFooterView().showStatus(StatusType.NONE,created.size() + "String_Node_Str",FooterView.DEFAULT_STATUS_CLEAR_DELAY);
        clientFactory.getShellView().getLogView().log(LogType.INFO,"String_Node_Str" + created + "String_Node_Str"+ accountId);
      }
    }
  }
);
}