nus-yam/ex-repair huggingface dataset:
Program: 144291
Project: 144291
Buggy source:
public PredicateObjectMapImpl(RDF rdf,List<PredicateMap> pms,List<ObjectMap> oms,List<RefObjectMap> roms){
  super(rdf);
  predList=new ArrayList<>();
  objList=new ArrayList<>();
  refObjList=new ArrayList<>();
  graphList=new ArrayList<>();
  if (pms == null) {
    throw new NullPointerException("String_Node_Str");
  }
 else   if (pms.isEmpty()) {
    throw new IllegalArgumentException("String_Node_Str");
  }
 else   if (oms == null && roms == null) {
    throw new NullPointerException("String_Node_Str");
  }
 else   if (oms == null && roms.isEmpty()) {
    throw new IllegalArgumentException("String_Node_Str");
  }
 else   if (roms == null && oms.isEmpty()) {
    throw new IllegalArgumentException("String_Node_Str");
  }
 else   if (oms != null && roms != null && oms.isEmpty() && roms.isEmpty()) {
    throw new IllegalArgumentException("String_Node_Str");
  }
 else {
    for (    PredicateMap pm : pms) {
      addPredicateMap(pm);
    }
    if (oms != null) {
      for (      ObjectMap om : oms) {
        addObjectMap(om);
      }
    }
    if (roms != null) {
      for (      RefObjectMap rom : roms) {
        addRefObjectMap(rom);
      }
    }
    setNode(getRDF().createBlankNode());
  }
}

Fixed version (ground truth):
PredicateObjectMapImpl(RDF rdf,List<PredicateMap> pms,List<ObjectMap> oms,List<RefObjectMap> roms){
  super(rdf);
  predList=new ArrayList<>();
  objList=new ArrayList<>();
  refObjList=new ArrayList<>();
  graphList=new ArrayList<>();
  if (pms == null) {
    throw new NullPointerException("String_Node_Str");
  }
 else   if (pms.isEmpty()) {
    throw new IllegalArgumentException("String_Node_Str");
  }
 else   if (oms == null && roms == null) {
    throw new NullPointerException("String_Node_Str");
  }
 else   if (oms == null && roms.isEmpty()) {
    throw new IllegalArgumentException("String_Node_Str");
  }
 else   if (roms == null && oms.isEmpty()) {
    throw new IllegalArgumentException("String_Node_Str");
  }
 else   if (oms != null && roms != null && oms.isEmpty() && roms.isEmpty()) {
    throw new IllegalArgumentException("String_Node_Str");
  }
 else {
    for (    PredicateMap pm : pms) {
      addPredicateMap(pm);
    }
    if (oms != null) {
      for (      ObjectMap om : oms) {
        addObjectMap(om);
      }
    }
    if (roms != null) {
      for (      RefObjectMap rom : roms) {
        addRefObjectMap(rom);
      }
    }
    setNode(getRDF().createBlankNode());
  }
}
Program: 144292
Project: 144292
Buggy source:
@Override public void setConstant(String constVal){
  if (getTermMapType() == TermMapType.CONSTANT_VALUED) {
    if (constVal != null) {
      this.constVal=constVal;
    }
 else {
      throw new NullPointerException("String_Node_Str");
    }
  }
 else {
    throw new IllegalStateException("String_Node_Str");
  }
}

Fixed version (ground truth):
@Override public void setConstant(String constVal){
  if (getTermMapType() == TermMapType.CONSTANT_VALUED) {
    if (constVal != null) {
      this.constVal=constVal;
      if (!constVal.startsWith("String_Node_Str")) {
        termtype=lc.createResource(R2RMLVocabulary.TERM_LITERAL);
      }
    }
 else {
      throw new NullPointerException("String_Node_Str");
    }
  }
 else {
    throw new IllegalStateException("String_Node_Str");
  }
}
Program: 144293
Project: 144293
Buggy source:
/** 
 * A Turtle parser.
 * @param is The InputStream to read from.
 * @return The set of RDFTriples that have been read.
 * @throws ParseException
 */
public static Set<RDFTriple> readTurtle(InputStream is) throws ParseException {
  Set<RDFTriple> s=new HashSet<RDFTriple>();
  TurtleParser tp=new TurtleParser(is,new RDFConsAdapter(s),IRI.create("String_Node_Str"));
  tp.parseDocument();
  return s;
}

Fixed version (ground truth):
/** 
 * A Turtle parser.
 * @param is The InputStream to read from.
 * @return The set of RDFTriples that have been read.
 * @throws ParseException
 */
public static Set<RDFTriple> readTurtle(InputStream is) throws ParseException {
  Set<RDFTriple> s=new HashSet<RDFTriple>();
  TurtleParser tp=new TurtleParser(is,new RDFConsAdapter(s),IRI.create("String_Node_Str").toString());
  tp.parseDocument();
  return s;
}
Program: 144294
Project: 144294
Buggy source:
@Test public void testQueries() throws DbException, IOException {
  run(db,new LdbcQuery2(19791209300143L,new Date(1354060800000L),LIMIT));
  db.close();
  workload.close();
}

Fixed version (ground truth):
@Test public void testQueries() throws DbException, IOException {
  run(db,new LdbcQuery1(30786325579101L,"String_Node_Str",LIMIT));
  run(db,new LdbcQuery2(19791209300143L,new Date(1354060800000L),LIMIT));
  run(db,new LdbcQuery3(15393162790207L,"String_Node_Str","String_Node_Str",new Date(1291161600000L),30,LIMIT));
  run(db,new LdbcQuery4(10995116278874L,new Date(1338508800000L),28,LIMIT));
  run(db,new LdbcQuery5(15393162790207L,new Date(1344643200000L),LIMIT));
  run(db,new LdbcQuery6(30786325579101L,"String_Node_Str",LIMIT));
  run(db,new LdbcQuery7(26388279067534L,LIMIT));
  run(db,new LdbcQuery8(2199023256816L,LIMIT));
  run(db,new LdbcQuery9(32985348834013L,new Date(1346112000000L),LIMIT));
  run(db,new LdbcQuery10(30786325579101L,7,LIMIT));
  run(db,new LdbcQuery11(30786325579101L,"String_Node_Str",2004,LIMIT));
  run(db,new LdbcQuery12(19791209300143L,"String_Node_Str",LIMIT));
  run(db,new LdbcQuery13(32985348833679L,26388279067108L));
  run(db,new LdbcQuery14(32985348833679L,2199023256862L));
  db.close();
  workload.close();
}
Program: 144297
Project: 144297
Buggy source:
/** 
 * Validates the file header against the schema used by the importer
 * @param s      schema to validate against
 * @param vLabel vertex type to validate against
 * @param header header of csv file
 * @return suffix of this vertex
 */
private void validateVHeader(WorkLoadSchema s,String vLabel,String[] header) throws SchemaViolationException {
  Set<String> props=s.getVertexProperties().get(vLabel);
  if (props == null)   throw new SchemaViolationException("String_Node_Str" + vLabel);
  for (  String col : header) {
    if (!props.contains(col)) {
      if (col.equals("String_Node_Str") && props.contains("String_Node_Str"))       continue;
 else       throw new SchemaViolationException("String_Node_Str" + vLabel + "String_Node_Str"+ col+ "String_Node_Str"+ props);
    }
    if (s.getVPropertyClass(vLabel,col) == null)     throw new SchemaViolationException("String_Node_Str" + vLabel + "String_Node_Str"+ col);
  }
}

Fixed version (ground truth):
/** 
 * Validates the file header against the schema used by the importer
 * @param s      schema to validate against
 * @param vLabel vertex type to validate against
 * @param header header of csv file
 * @return suffix of this vertex
 */
private void validateVHeader(WorkLoadSchema s,String vLabel,String[] header) throws SchemaViolationException {
  Set<String> props=s.getVertexProperties().get(vLabel);
  if (props == null)   throw new SchemaViolationException("String_Node_Str" + vLabel);
  for (  String col : header) {
    if (!props.contains(col)) {
      if (col.equals("String_Node_Str") && props.contains("String_Node_Str")) {
        continue;
      }
      if (col.equals("String_Node_Str") && props.contains("String_Node_Str")) {
        continue;
      }
 else       throw new SchemaViolationException("String_Node_Str" + vLabel + "String_Node_Str"+ col+ "String_Node_Str"+ props);
    }
    if (s.getVPropertyClass(vLabel,col) == null)     throw new SchemaViolationException("String_Node_Str" + vLabel + "String_Node_Str"+ col);
  }
}
Program: 144301
Project: 144301
Buggy source:
private void buildIndexes(){
  JanusGraphManagement management=graph.openManagement();
  for (  Map.Entry<PropertyKey,String> entry : vertexIndexes.entrySet()) {
    management.buildIndex(entry.getValue(),Vertex.class).addKey(entry.getKey()).buildCompositeIndex();
    management.updateIndex(management.getGraphIndex(entry.getValue()),SchemaAction.REINDEX);
  }
  management.commit();
}

Fixed version (ground truth):
private void buildIndexes(){
  for (  String property : vertexIndexes) {
    JanusGraphManagement management=graph.openManagement();
    PropertyKey pk=management.getPropertyKey(property);
    JanusGraphIndex index=management.buildIndex("String_Node_Str" + property,Vertex.class).addKey(pk).buildCompositeIndex();
    management.updateIndex(index,SchemaAction.REINDEX);
    management.commit();
  }
}
Program: 144306
Project: 144306
Buggy source:
@GenerateMicroBenchmark public Optional<Integer> parallel(){
  return integerList.stream().parallel().filter(l -> {
    BlackHole.consumeCPU(Q);
    return false;
  }
).findFirst();
}

Fixed version (ground truth):
@Benchmark public Optional<Integer> parallel(){
  return integerList.stream().parallel().filter(l -> {
    Blackhole.consumeCPU(Q);
    return false;
  }
).findFirst();
}
Program: 144307
Project: 144307
Buggy source:
@GenerateMicroBenchmark public void loop(BlackHole bh){
  for (  Integer i : integerList) {
    BlackHole.consumeCPU(Q);
    bh.consume(i);
  }
}

Fixed version (ground truth):
@Benchmark public void loop(Blackhole bh){
  for (  Integer i : integerList) {
    Blackhole.consumeCPU(Q);
    bh.consume(i);
  }
}
Program: 144308
Project: 144308
Buggy source:
@GenerateMicroBenchmark public Optional<Integer> sequential(){
  return integerList.stream().filter(l -> {
    BlackHole.consumeCPU(Q);
    return false;
  }
).findFirst();
}

Fixed version (ground truth):
@Benchmark public Optional<Integer> sequential(){
  return integerList.stream().filter(l -> {
    Blackhole.consumeCPU(Q);
    return false;
  }
).findFirst();
}
Program: 144309
Project: 144309
Buggy source:
@GenerateMicroBenchmark public Optional<Integer> parallel(){
  return integerList.stream().parallel().filter(l -> {
    BlackHole.consumeCPU(Q);
    return false;
  }
).findFirst();
}

Fixed version (ground truth):
@Benchmark public Optional<Integer> parallel(){
  return integerList.stream().parallel().filter(l -> {
    Blackhole.consumeCPU(Q);
    return false;
  }
).findFirst();
}
Program: 144310
Project: 144310
Buggy source:
@GenerateMicroBenchmark public void loop(BlackHole bh){
  for (  Integer i : integerList) {
    BlackHole.consumeCPU(Q);
    bh.consume(i);
  }
}

Fixed version (ground truth):
@Benchmark public void loop(Blackhole bh){
  for (  Integer i : integerList) {
    Blackhole.consumeCPU(Q);
    bh.consume(i);
  }
}
Program: 144311
Project: 144311
Buggy source:
@GenerateMicroBenchmark public Optional<Integer> sequential(){
  return integerList.stream().filter(l -> {
    BlackHole.consumeCPU(Q);
    return false;
  }
).findFirst();
}

Fixed version (ground truth):
@Benchmark public Optional<Integer> sequential(){
  return integerList.stream().filter(l -> {
    Blackhole.consumeCPU(Q);
    return false;
  }
).findFirst();
}
Program: 144312
Project: 144312
Buggy source:
@GenerateMicroBenchmark public Optional<Integer> parallelUnorderedNoLimit(){
  return integerList.stream().parallel().unordered().filter(l -> false).findFirst();
}

Fixed version (ground truth):
@Benchmark public Optional<Integer> parallelUnorderedNoLimit(){
  return integerList.stream().parallel().unordered().filter(l -> false).findFirst();
}
Program: 144313
Project: 144313
Buggy source:
@GenerateMicroBenchmark public Optional<Integer> sequentialUnorderedNoLimit(){
  return integerList.stream().unordered().filter(l -> false).findFirst();
}

Fixed version (ground truth):
@Benchmark public Optional<Integer> sequentialUnorderedNoLimit(){
  return integerList.stream().unordered().filter(l -> false).findFirst();
}
Program: 144314
Project: 144314
Buggy source:
@GenerateMicroBenchmark public Optional<Integer> parallelUnorderedLimit(){
  return integerList.stream().parallel().unordered().limit(N).filter(l -> false).findFirst();
}

Fixed version (ground truth):
@Benchmark public Optional<Integer> parallelUnorderedLimit(){
  return integerList.stream().parallel().unordered().limit(N).filter(l -> false).findFirst();
}
Program: 144315
Project: 144315
Buggy source:
@GenerateMicroBenchmark public Optional<Integer> parallelOrderedNoLimit(){
  return integerList.stream().parallel().filter(l -> false).findFirst();
}

Fixed version (ground truth):
@Benchmark public Optional<Integer> parallelOrderedNoLimit(){
  return integerList.stream().parallel().filter(l -> false).findFirst();
}
Program: 144316
Project: 144316
Buggy source:
@GenerateMicroBenchmark public Optional<Integer> sequentialUnorderedLimit(){
  return integerList.stream().unordered().limit(N).filter(l -> false).findFirst();
}

Fixed version (ground truth):
@Benchmark public Optional<Integer> sequentialUnorderedLimit(){
  return integerList.stream().unordered().limit(N).filter(l -> false).findFirst();
}
Program: 144317
Project: 144317
Buggy source:
@GenerateMicroBenchmark public Optional<Integer> parallelOrderedLimit(){
  return integerList.stream().parallel().limit(N).filter(l -> false).findFirst();
}

Fixed version (ground truth):
@Benchmark public Optional<Integer> parallelOrderedLimit(){
  return integerList.stream().parallel().limit(N).filter(l -> false).findFirst();
}
Program: 144318
Project: 144318
Buggy source:
@GenerateMicroBenchmark public Optional<Integer> sequentialOrderedLimit(){
  return integerList.stream().limit(N).filter(l -> false).findFirst();
}

Fixed version (ground truth):
@Benchmark public Optional<Integer> sequentialOrderedLimit(){
  return integerList.stream().limit(N).filter(l -> false).findFirst();
}
Program: 144319
Project: 144319
Buggy source:
@GenerateMicroBenchmark public Optional<Integer> sequentialOrderedNoLimit(){
  return integerList.stream().filter(l -> false).findFirst();
}

Fixed version (ground truth):
@Benchmark public Optional<Integer> sequentialOrderedNoLimit(){
  return integerList.stream().filter(l -> false).findFirst();
}
Program: 144320
Project: 144320
Buggy source:
@Override public View onCreateView(LayoutInflater inflater,ViewGroup container,Bundle savedInstanceState){
  if (container == null) {
    return null;
  }
  view=(RelativeLayout)inflater.inflate(R.layout.fragment_maps,container,false);
  Bundle bundle=getArguments();
  mMarkers=bundle.getParcelableArrayList("String_Node_Str");
  setUpMapIfNeeded(mMarkers);
  return view;
}

Fixed version (ground truth):
@Override public View onCreateView(LayoutInflater inflater,ViewGroup container,Bundle savedInstanceState){
  if (view != null) {
    ViewGroup parent=(ViewGroup)view.getParent();
    if (parent != null) {
      parent.removeView(view);
    }
  }
  try {
    view=inflater.inflate(R.layout.fragment_maps,container,false);
  }
 catch (  InflateException e) {
  }
  Bundle bundle=getArguments();
  mMarkers=bundle.getParcelableArrayList("String_Node_Str");
  setUpMapIfNeeded(mMarkers);
  return view;
}
Program: 144321
Project: 144321
Buggy source:
@Override public View onCreateView(LayoutInflater inflater,ViewGroup container,Bundle savedInstanceState){
  ViewGroup rootView=(ViewGroup)inflater.inflate(R.layout.fragment_ateneo,container,false);
  mPager=(ViewPager)rootView.findViewById(R.id.pager);
  mAdapter=new AteneoFragmentAdapter(getActivity().getSupportFragmentManager());
  mPager.setAdapter(mAdapter);
  TitlePageIndicator titleIndicator=(TitlePageIndicator)rootView.findViewById(R.id.titles);
  titleIndicator.setViewPager(mPager);
  titleIndicator.setCurrentItem(1);
  return rootView;
}

Fixed version (ground truth):
@Override public View onCreateView(LayoutInflater inflater,ViewGroup container,Bundle savedInstanceState){
  ViewGroup rootView=(ViewGroup)inflater.inflate(R.layout.fragment_ateneo,container,false);
  mPager=(ViewPager)rootView.findViewById(R.id.pager);
  mAdapter=new AteneoFragmentAdapter(getChildFragmentManager());
  mPager.setAdapter(mAdapter);
  TitlePageIndicator titleIndicator=(TitlePageIndicator)rootView.findViewById(R.id.titles);
  titleIndicator.setViewPager(mPager);
  titleIndicator.setCurrentItem(1);
  return rootView;
}
Program: 144323
Project: 144323
Buggy source:
public String viewStatusList(){
  int customerId=0;
  if (commonUtils.getCustomerIdFromSession() != null) {
    customerId=commonUtils.getCustomerIdFromSession();
  }
 else {
    customerId=getClientId();
  }
  List<Orders> orderEntityList=new ArrayList<Orders>();
  String column=getColumnFilter();
  if (StringUtils.isNotBlank(column)) {
    orderEntityList=orderService.findOrdersByCriteriaOnGoing(column,order.getOrderKeyword(),getClientId());
  }
 else {
    orderEntityList=orderStatusLogsService.findAllOrders();
  }
  for (  Orders ordersElem : orderEntityList) {
    if (ordersElem.getCustomerId() != customerId && customerId != getClientId()) {
      continue;
    }
    orders.add(transformToOrderFormBean(ordersElem));
  }
  return SUCCESS;
}

Fixed version (ground truth):
public String viewStatusList(){
  int customerId=0;
  if (commonUtils.getCustomerIdFromSession() != null) {
    customerId=commonUtils.getCustomerIdFromSession();
  }
 else {
    customerId=getClientId();
  }
  List<Orders> orderEntityList=new ArrayList<Orders>();
  int customerId=0;
  if (commonUtils.getCustomerIdFromSession() != null) {
    customerId=commonUtils.getCustomerIdFromSession();
  }
 else {
    customerId=getClientId();
  }
  String column=getColumnFilter();
  if (StringUtils.isNotBlank(column)) {
    orderEntityList=orderService.findOrdersByCriteriaOnGoing(column,order.getOrderKeyword(),getClientId());
  }
 else {
    orderEntityList=orderStatusLogsService.findAllOrders();
  }
  for (  Orders ordersElem : orderEntityList) {
    if (ordersElem.getCustomerId() != customerId && customerId != getClientId()) {
      continue;
    }
    orders.add(transformToOrderFormBean(ordersElem));
  }
  return SUCCESS;
}
Program: 144326
Project: 144326
Buggy source:
@Override public Integer addUser(User user){
  log.debug("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
  try {
    Session session=getSessionFactory().getCurrentSession();
    Integer userId=(Integer)session.save(user);
    log.debug("String_Node_Str");
    return userId;
  }
 catch (  RuntimeException re) {
    log.error("String_Node_Str",re);
    throw re;
  }
}

Fixed version (ground truth):
@Override public Integer addUser(User user){
  try {
    Session session=getSessionFactory().getCurrentSession();
    Integer userId=(Integer)session.save(user);
    log.debug("String_Node_Str");
    return userId;
  }
 catch (  RuntimeException re) {
    log.error("String_Node_Str",re);
    throw re;
  }
}
Program: 144327
Project: 144327
Buggy source:
public String viewContacts(){
  Integer customerId=getCustomerSessionId();
  List<Contacts> contactEntityList=customerService.findContactByRefIdAndType("String_Node_Str",customerId);
  for (  Contacts contactElem : contactEntityList) {
    contacts.add(transformToFormBeanContacts(contactElem));
  }
  return SUCCESS;
}

Fixed version (ground truth):
public String viewContacts(){
  Integer customerId=getCustomerSessionId();
  List<Contacts> contactEntityList=customerService.findContactsByCustomer(customerId);
  for (  Contacts contactElem : contactEntityList) {
    contacts.add(transformToFormBeanContacts(contactElem));
  }
  return SUCCESS;
}
Program: 144328
Project: 144328
Buggy source:
public void validateOnSubmit(CustomerBean customerBean){
  clearErrorsAndMessages();
  if (StringUtils.isBlank(customerBean.getCustomerName())) {
    addFieldError("String_Node_Str",getText("String_Node_Str"));
  }
  if (StringUtils.isBlank(customerBean.getPhone())) {
    addFieldError("String_Node_Str",getText("String_Node_Str"));
  }
  if (StringUtils.isBlank(customerBean.getMobile())) {
    addFieldError("String_Node_Str",getText("String_Node_Str"));
  }
  if (StringUtils.isBlank(customerBean.getEmail())) {
    addFieldError("String_Node_Str",getText("String_Node_Str"));
  }
}

Fixed version (ground truth):
public void validateOnSubmit(CustomerBean customerBean){
  clearErrorsAndMessages();
  if (StringUtils.isBlank(customerBean.getCustomerName())) {
    addFieldError("String_Node_Str",getText("String_Node_Str"));
  }
  if (StringUtils.isBlank(customerBean.getEmail())) {
    addFieldError("String_Node_Str",getText("String_Node_Str"));
  }
}
Program: 144330
Project: 144330
Buggy source:
public String loadAddOrderPage(){
  System.out.println("String_Node_Str" + commonUtils.getUserNameFromSession());
  User userEntity=userService.findUserByUserName(commonUtils.getUserNameFromSession());
  if (userEntity.getUserType().equals("String_Node_Str")) {
    if (userEntity.getCustomerId() != null) {
      Customer customerEntity=customerService.findCustomerById(userEntity.getCustomerId());
      customerList.add(customerEntity);
    }
 else {
      customerList=customerService.findAllCustomer();
    }
  }
 else {
    customerList=customerService.findAllCustomer();
  }
  return SUCCESS;
}

Fixed version (ground truth):
public String loadAddOrderPage(){
  System.out.println("String_Node_Str" + commonUtils.getUserNameFromSession());
  User userEntity=userService.findUserByUserName(commonUtils.getUserNameFromSession());
  userType=userEntity.getUserType();
  if (userEntity.getUserType().equals("String_Node_Str")) {
    if (userEntity.getCustomerId() != null) {
      Customer customerEntity=customerService.findCustomerById(userEntity.getCustomerId());
      customerList.add(customerEntity);
    }
 else {
      customerList=customerService.findAllCustomer();
    }
  }
 else {
    customerList=customerService.findAllCustomer();
  }
  return SUCCESS;
}
Program: 144333
Project: 144333
Buggy source:
public String viewStatusListItems(){
  List<OrderItems> orderItemEntityList=orderStatusLogsService.findAllItemsByOrderId(orderIdParam);
  Orders orderEntity=orderService.findOrdersById(orderIdParam);
  bookingNumber=orderEntity.getOrderNumber();
  order=transformToOrderFormBean(orderEntity);
  for (  OrderItems orderItemsElem : orderItemEntityList) {
    orderItems.add(transformToOrderItemFormBean(orderItemsElem));
  }
  return SUCCESS;
}

Fixed version (ground truth):
public String viewStatusListItems(){
  Map sessionAttributes=ActionContext.getContext().getSession();
  if (orderIdParam == null) {
    orderIdParam=(Integer)sessionAttributes.get(orderIdParam);
  }
  List<OrderItems> orderItemEntityList=orderStatusLogsService.findAllItemsByOrderId(orderIdParam);
  Orders orderEntity=orderService.findOrdersById(orderIdParam);
  bookingNumber=orderEntity.getOrderNumber();
  order=transformToOrderFormBean(orderEntity);
  for (  OrderItems orderItemsElem : orderItemEntityList) {
    orderItems.add(transformToOrderItemFormBean(orderItemsElem));
  }
  return SUCCESS;
}
Program: 144334
Project: 144334
Buggy source:
public String addVendorInPlanningError(){
  Map sessionAttributes=ActionContext.getContext().getSession();
  OrderItems entity=operationsService.findOrderItemById((Integer)sessionAttributes.get("String_Node_Str"));
  orderItem=transformToOrderItemFormBean(entity);
  Orders orderEntity=orderService.findOrdersById((Integer)sessionAttributes.get("String_Node_Str"));
  order=transformToOrderFormBean(orderEntity);
  if (orderItem.getVesselScheduleId() != null) {
    VesselSchedules vesselScheduleEntity=vesselSchedulesService.findVesselSchedulesByIdVoyageNumber(orderItem.getVesselScheduleId());
    vesselSchedule=transformToFormBeanVesselSchedule(vesselScheduleEntity);
  }
  vendorTruckingOriginList=vendorService.findVendorTruckByLocation(order.getOriginationPort());
  vendorTruckingDestinationList=vendorService.findVendorTruckByLocation(order.getDestinationPort());
  nameSizeList=(List)sessionAttributes.get("String_Node_Str");
  orderItems=(List)sessionAttributes.get("String_Node_Str");
  clearErrorsAndMessages();
  addActionMessage("String_Node_Str");
  return SUCCESS;
}

Fixed version (ground truth):
public String addVendorInPlanningError(){
  Map sessionAttributes=ActionContext.getContext().getSession();
  OrderItems entity=operationsService.findOrderItemById((Integer)sessionAttributes.get("String_Node_Str"));
  orderItem=transformToOrderItemFormBean(entity);
  Orders orderEntity=orderService.findOrdersById((Integer)sessionAttributes.get("String_Node_Str"));
  order=transformToOrderFormBean(orderEntity);
  System.out.print("String_Node_Str" + entity.getVesselScheduleId());
  if (entity.getVesselScheduleId() != null) {
    VesselSchedules vesselScheduleEntity=vesselSchedulesService.findVesselSchedulesByIdVoyageNumber(orderItem.getVesselScheduleId());
    vesselSchedule=transformToFormBeanVesselSchedule(vesselScheduleEntity);
  }
  vendorTruckingOriginList=vendorService.findVendorTruckByLocation(order.getOriginationPort());
  vendorTruckingDestinationList=vendorService.findVendorTruckByLocation(order.getDestinationPort());
  nameSizeList=(List)sessionAttributes.get("String_Node_Str");
  orderItems=(List)sessionAttributes.get("String_Node_Str");
  orderItemOriginVendor.add(transformToOrderItemFormBean(entity));
  orderItemDestinationVendor.add(transformToOrderItemFormBean(entity));
  clearErrorsAndMessages();
  addActionMessage("String_Node_Str");
  return SUCCESS;
}
Program: 144335
Project: 144335
Buggy source:
public String reloadInlandFreightPlanning(){
  Map sessionAttributes=ActionContext.getContext().getSession();
  OrderItems entity=operationsService.findOrderItemById((Integer)sessionAttributes.get("String_Node_Str"));
  orderItem=transformToOrderItemFormBean(entity);
  Orders orderEntity=orderService.findOrdersById((Integer)sessionAttributes.get("String_Node_Str"));
  order=transformToOrderFormBean(orderEntity);
  if (orderItem.getVesselScheduleId() != null) {
    VesselSchedules vesselScheduleEntity=vesselSchedulesService.findVesselSchedulesByIdVoyageNumber(orderItem.getVesselScheduleId());
    vesselSchedule=transformToFormBeanVesselSchedule(vesselScheduleEntity);
  }
  vendorTruckingOriginList=vendorService.findVendorTruckByLocation(order.getOriginationPort());
  vendorTruckingDestinationList=vendorService.findVendorTruckByLocation(order.getDestinationPort());
  nameSizeList=(List)sessionAttributes.get("String_Node_Str");
  orderItems=(List)sessionAttributes.get("String_Node_Str");
  clearErrorsAndMessages();
  addActionMessage("String_Node_Str");
  if ("String_Node_Str".equals(entity.getStatus())) {
    return "String_Node_Str";
  }
 else   if ("String_Node_Str".equals(entity.getStatus())) {
    return "String_Node_Str";
  }
 else {
    return "String_Node_Str";
  }
}

Fixed version (ground truth):
public String reloadInlandFreightPlanning(){
  Map sessionAttributes=ActionContext.getContext().getSession();
  OrderItems entity=operationsService.findOrderItemById((Integer)sessionAttributes.get("String_Node_Str"));
  orderItem=transformToOrderItemFormBean(entity);
  Orders orderEntity=orderService.findOrdersById((Integer)sessionAttributes.get("String_Node_Str"));
  order=transformToOrderFormBean(orderEntity);
  System.out.print("String_Node_Str" + entity.getVesselScheduleId());
  if (entity.getVesselScheduleId() != null) {
    VesselSchedules vesselScheduleEntity=vesselSchedulesService.findVesselSchedulesByIdVoyageNumber(orderItem.getVesselScheduleId());
    vesselSchedule=transformToFormBeanVesselSchedule(vesselScheduleEntity);
  }
  vendorTruckingOriginList=vendorService.findVendorTruckByLocation(order.getOriginationPort());
  vendorTruckingDestinationList=vendorService.findVendorTruckByLocation(order.getDestinationPort());
  nameSizeList=(List)sessionAttributes.get("String_Node_Str");
  orderItems=(List)sessionAttributes.get("String_Node_Str");
  orderItemOriginVendor.add(transformToOrderItemFormBean(entity));
  orderItemDestinationVendor.add(transformToOrderItemFormBean(entity));
  clearErrorsAndMessages();
  addActionMessage("String_Node_Str");
  if ("String_Node_Str".equals(entity.getStatus())) {
    return "String_Node_Str";
  }
 else   if ("String_Node_Str".equals(entity.getStatus())) {
    return "String_Node_Str";
  }
 else {
    return "String_Node_Str";
  }
}
Program: 144338
Project: 144338
Buggy source:
public String updateStatus(){
  Map sessionAttributes=ActionContext.getContext().getSession();
  try {
    OrderStatusLogs orderStatusLogsEntity=transformToOrderStatusLogsEntity(orderStatusLogsBean);
    sessionAttributes.put("String_Node_Str",orderStatusLogsEntity.getOrderItemId());
    orderStatusLogsEntity.setCreatedTimestamp(new Date());
    orderStatusLogsEntity.setCreatedBy(commonUtils.getUserNameFromSession());
    orderStatusLogsService.addStatus(orderStatusLogsEntity);
  }
 catch (  Exception e) {
    addActionError("String_Node_Str");
    return INPUT;
  }
  return SUCCESS;
}

Fixed version (ground truth):
public String updateStatus(){
  Map sessionAttributes=ActionContext.getContext().getSession();
  try {
    if (orderStatusLogsBean.getStatus().equals("String_Node_Str")) {
      sessionAttributes.put("String_Node_Str",orderStatusLogsBean.getOrderItemId());
      return "String_Node_Str";
    }
 else {
      OrderStatusLogs orderStatusLogsEntity=transformToOrderStatusLogsEntity(orderStatusLogsBean);
      sessionAttributes.put("String_Node_Str",orderStatusLogsEntity.getOrderItemId());
      orderStatusLogsEntity.setCreatedTimestamp(new Date());
      orderStatusLogsEntity.setCreatedBy(commonUtils.getUserNameFromSession());
      orderStatusLogsService.addStatus(orderStatusLogsEntity);
    }
  }
 catch (  Exception e) {
    addActionError("String_Node_Str");
    sessionAttributes.put("String_Node_Str",orderItemIdParam);
    return INPUT;
  }
  return SUCCESS;
}
Program: 144339
Project: 144339
Buggy source:
public String serviceAccomplishedStatus(){
  Map sessionAttributes=ActionContext.getContext().getSession();
  Orders orderEntity=orderService.findOrdersById(orderIdParam);
  List<OrderItems> orderItemEntityList=orderStatusLogsService.findAllItemsByOrderId(orderIdParam);
  Integer checkAllStatus=0;
  for (  OrderItems orderItemsElem : orderItemEntityList) {
    List<OrderStatusLogs> orderStatusEntityList=orderStatusLogsService.findAllShipmentLogs(orderItemsElem.getOrderItemId());
    for (    OrderStatusLogs orderStatusLogsElem : orderStatusEntityList) {
      if (orderStatusLogsElem.getStatus().equals("String_Node_Str") || orderStatusLogsElem.getStatus().equals("String_Node_Str")) {
        checkAllStatus+=1;
      }
 else       if (orderStatusLogsElem.getStatus().equals("String_Node_Str")) {
        orderEntity.setOrderStatus("String_Node_Str");
        orderService.updateOrder(orderEntity);
        return SUCCESS;
      }
    }
  }
  if (checkAllStatus >= orderItemEntityList.size() && orderItemEntityList.size() >= 1) {
    orderEntity.setOrderStatus("String_Node_Str");
    orderService.updateOrder(orderEntity);
    return SUCCESS;
  }
 else {
    sessionAttributes.put("String_Node_Str",orderIdParam);
    return "String_Node_Str";
  }
}

Fixed version (ground truth):
public String serviceAccomplishedStatus(){
  Map sessionAttributes=ActionContext.getContext().getSession();
  Orders orderEntity=orderService.findOrdersById(orderIdParam);
  List<OrderItems> orderItemEntityList=orderStatusLogsService.findAllItemsByOrderId(orderIdParam);
  Integer checkAllStatus=0;
  for (  OrderItems orderItemsElem : orderItemEntityList) {
    List<OrderStatusLogs> orderStatusEntityList=orderStatusLogsService.findAllShipmentLogs(orderItemsElem.getOrderItemId());
    for (    OrderStatusLogs orderStatusLogsElem : orderStatusEntityList) {
      if (orderStatusLogsElem.getStatus().equals("String_Node_Str") || orderStatusLogsElem.getStatus().equals("String_Node_Str") || (orderEntity.getServiceMode().equals("String_Node_Str") && orderStatusLogsElem.getStatus().equals("String_Node_Str"))) {
        checkAllStatus+=1;
      }
 else       if (orderStatusLogsElem.getStatus().equals("String_Node_Str")) {
        orderEntity.setOrderStatus("String_Node_Str");
        orderService.updateOrder(orderEntity);
        return SUCCESS;
      }
    }
  }
  if (checkAllStatus >= orderItemEntityList.size() && orderItemEntityList.size() >= 1) {
    orderEntity.setOrderStatus("String_Node_Str");
    orderService.updateOrder(orderEntity);
    return SUCCESS;
  }
 else {
    sessionAttributes.put("String_Node_Str",orderIdParam);
    return "String_Node_Str";
  }
}
Program: 144340
Project: 144340
Buggy source:
private void findCurrentUserPermissions(Integer userId){
  List<Permission> selectedPermissionsList=(List<Permission>)permissionService.findPermissionByUser(getClientId(),userId);
  if (null != selectedPermissionsList) {
    preSelectedPermissions=new String[selectedPermissionsList.size()];
    preSelectedPermissionNames=new String[selectedPermissionsList.size()];
  }
  int i;
  if (isEmpty(selectedPermissionsList.size())) {
    for (i=0; i < selectedPermissionsList.size(); i++) {
      String permissionId;
      permissionId=selectedPermissionsList.get(i).getPermissionId().toString();
      preSelectedPermissions[i]=permissionId;
      String permissionName=selectedPermissionsList.get(i).getDescription();
      preSelectedPermissionNames[i]=permissionName;
    }
  }
}

Fixed version (ground truth):
private void findCurrentUserPermissions(Integer userId){
  List<Permission> selectedPermissionsList=(List<Permission>)permissionService.findPermissionByUser(getClientId(),userId);
  preSelectedPermissions=new String[selectedPermissionsList.size()];
  int i;
  for (i=0; i < selectedPermissionsList.size(); i++) {
    String permissionId;
    permissionId=selectedPermissionsList.get(i).getPermissionId().toString();
    preSelectedPermissions[i]=permissionId;
  }
}
Program: 144341
Project: 144341
Buggy source:
public String home(){
  portsList=parameterService.getParameterMap(ParameterConstants.PORTS);
  Booking=notificationService.countAll();
  Customer=notificationService.countAllCustomer();
  User=notificationService.countAllUser();
  Vendor=notificationService.countAllVendor();
  AllNotification=notificationService.countAllNotification();
  System.out.println("String_Node_Str" + Booking);
  System.out.println("String_Node_Str" + Customer);
  System.out.println("String_Node_Str" + User);
  System.out.println("String_Node_Str" + Vendor);
  System.out.println("String_Node_Str" + AllNotification);
  changeOrigin();
  viewStatusList();
  return SUCCESS;
}

Fixed version (ground truth):
public String home(){
  System.out.println("String_Node_Str" + username);
  portsList=parameterService.getParameterMap(ParameterConstants.PORTS);
  Booking=notificationService.countAll();
  Customer=notificationService.countAllCustomer();
  User=notificationService.countAllUser();
  Vendor=notificationService.countAllVendor();
  AllNotification=notificationService.countAllNotification();
  System.out.println("String_Node_Str" + Booking);
  System.out.println("String_Node_Str" + Customer);
  System.out.println("String_Node_Str" + User);
  System.out.println("String_Node_Str" + Vendor);
  System.out.println("String_Node_Str" + AllNotification);
  changeOrigin();
  return SUCCESS;
}
Program: 144342
Project: 144342
Buggy source:
public String execute() throws Exception {
  portsList=parameterService.getParameterMap(ParameterConstants.PORTS);
  log.debug("String_Node_Str");
  HttpServletRequest request=ServletActionContext.getRequest();
  Principal user=request.getUserPrincipal();
  this.setUsername(request.getUserPrincipal().getName());
  User userEntity=userService.findUserByUserName(username);
  if (userEntity != null) {
    userService.updateLastVisitDate(userEntity);
    sessionAttributes.put("String_Node_Str",userEntity.getClient().getClientId());
    sessionAttributes.put("String_Node_Str",userEntity);
    sessionAttributes.put("String_Node_Str",userEntity.getFirstName() + "String_Node_Str" + userEntity.getLastName());
    Booking=notificationService.countAll();
    Customer=notificationService.countAllCustomer();
    User=notificationService.countAllUser();
    Vendor=notificationService.countAllVendor();
    AllNotification=notificationService.countAllNotification();
    System.out.println("String_Node_Str" + Booking);
    System.out.println("String_Node_Str" + Customer);
    System.out.println("String_Node_Str" + User);
    System.out.println("String_Node_Str" + Vendor);
    System.out.println("String_Node_Str" + AllNotification);
    return SUCCESS;
  }
 else {
    log.debug("String_Node_Str");
    clearErrorsAndMessages();
    addActionError(getText("String_Node_Str"));
    return INPUT;
  }
}

Fixed version (ground truth):
public String execute() throws Exception {
  portsList=parameterService.getParameterMap(ParameterConstants.PORTS);
  log.debug("String_Node_Str");
  HttpServletRequest request=ServletActionContext.getRequest();
  Principal user=request.getUserPrincipal();
  this.setUsername(request.getUserPrincipal().getName());
  User userEntity=userService.findUserByUserName(username);
  if (userEntity != null) {
    userService.updateLastVisitDate(userEntity);
    sessionAttributes.put("String_Node_Str",userEntity.getClient().getClientId());
    sessionAttributes.put("String_Node_Str",userEntity);
    sessionAttributes.put("String_Node_Str",userEntity.getFirstName() + "String_Node_Str" + userEntity.getLastName());
    Booking=notificationService.countAll();
    Customer=notificationService.countAllCustomer();
    User=notificationService.countAllUser();
    Vendor=notificationService.countAllVendor();
    AllNotification=notificationService.countAllNotification();
    System.out.println("String_Node_Str" + Booking);
    System.out.println("String_Node_Str" + Customer);
    System.out.println("String_Node_Str" + User);
    System.out.println("String_Node_Str" + Vendor);
    System.out.println("String_Node_Str" + AllNotification);
    viewStatusList();
    return SUCCESS;
  }
 else {
    log.debug("String_Node_Str");
    clearErrorsAndMessages();
    addActionError(getText("String_Node_Str"));
    return INPUT;
  }
}
Program: 144347
Project: 144347
Buggy source:
public OrderStatusLogsBean transformToOrderStatusLogsFormBean(OrderStatusLogs entity){
  OrderStatusLogsBean formBean=new OrderStatusLogsBean();
  formBean.setStatusId(entity.getStatusId());
  formBean.setCreatedTimestamp(entity.getCreatedTimestamp());
  formBean.setActualDate(entity.getActualDate());
  formBean.setStatus(entity.getStatus());
  formBean.setCreatedBy(entity.getCreatedBy());
  formBean.setNameSize(orderService.findOrderItemByOrderItemId(entity.getOrderItemId()).getNameSize());
  formBean.setOrderItemId(entity.getOrderItemId());
  formBean.setOrderId(operationsService.findOrderItemById(entity.getOrderItemId()).getOrderId());
  return formBean;
}

Fixed version (ground truth):
public OrderStatusLogsBean transformToOrderStatusLogsFormBean(OrderStatusLogs entity){
  OrderStatusLogsBean formBean=new OrderStatusLogsBean();
  formBean.setStatusId(entity.getStatusId());
  formBean.setCreatedTimestamp(entity.getCreatedTimestamp());
  formBean.setActualDate(entity.getActualDate());
  formBean.setStatus(entity.getStatus());
  User userEntity=userService.findUserByUserName(entity.getCreatedBy());
  formBean.setCreatedBy(userEntity.getFirstName() + "String_Node_Str" + userEntity.getLastName());
  formBean.setNameSize(orderService.findOrderItemByOrderItemId(entity.getOrderItemId()).getNameSize());
  formBean.setOrderItemId(entity.getOrderItemId());
  formBean.setOrderId(operationsService.findOrderItemById(entity.getOrderItemId()).getOrderId());
  return formBean;
}
Program: 144348
Project: 144348
Buggy source:
public String updateBulkStatus(){
  Map sessionAttributes=ActionContext.getContext().getSession();
  try {
    String[] checkedItemsInSession=(String[])sessionAttributes.get("String_Node_Str");
    for (    String checkValue : checkedItemsInSession) {
      Integer bulkId=Integer.parseInt(checkValue);
      OrderItems orderItemEntity=orderStatusLogsService.findOrderItemById(bulkId);
      orderStatusLogsBean.setOrderItemId(orderItemEntity.getOrderItemId());
      OrderStatusLogs orderStatusLogsEntity=transformToOrderStatusLogsEntity(orderStatusLogsBean);
      sessionAttributes.put("String_Node_Str",orderStatusLogsEntity.getOrderItemId());
      orderStatusLogsEntity.setCreatedTimestamp(new Date());
      orderStatusLogsEntity.setCreatedBy(commonUtils.getUserNameFromSession());
      orderStatusLogsService.addStatus(orderStatusLogsEntity);
      orderItemEntity.setStatus(orderStatusLogsBean.getStatus());
      orderStatusLogsService.updateStatusOrderItem(orderItemEntity);
      Orders orderEntity=orderService.findOrdersById(orderIdParam);
      orderEntity.setOrderStatus(orderStatusLogsBean.getStatus());
      orderService.updateOrder(orderEntity);
    }
  }
 catch (  Exception e) {
    addActionError("String_Node_Str");
    return INPUT;
  }
  return SUCCESS;
}

Fixed version (ground truth):
public String updateBulkStatus(){
  Map sessionAttributes=ActionContext.getContext().getSession();
  try {
    String[] checkedItemsInSession=(String[])sessionAttributes.get("String_Node_Str");
    for (    String checkValue : checkedItemsInSession) {
      Integer bulkId=Integer.parseInt(checkValue);
      OrderItems orderItemEntity=orderStatusLogsService.findOrderItemById(bulkId);
      orderStatusLogsBean.setOrderItemId(orderItemEntity.getOrderItemId());
      OrderStatusLogs orderStatusLogsEntity=transformToOrderStatusLogsEntity(orderStatusLogsBean);
      sessionAttributes.put("String_Node_Str",orderStatusLogsEntity.getOrderItemId());
      orderStatusLogsEntity.setCreatedTimestamp(new Date());
      orderStatusLogsEntity.setCreatedBy(commonUtils.getUserNameFromSession());
      orderStatusLogsService.addStatus(orderStatusLogsEntity);
      orderItemEntity.setStatus(orderStatusLogsBean.getStatus());
      orderStatusLogsService.updateStatusOrderItem(orderItemEntity);
    }
  }
 catch (  Exception e) {
    addActionError("String_Node_Str");
    return INPUT;
  }
  return SUCCESS;
}
Program: 144349
Project: 144349
Buggy source:
public String updateStatus(){
  Map sessionAttributes=ActionContext.getContext().getSession();
  try {
    OrderStatusLogs orderStatusLogsEntity=transformToOrderStatusLogsEntity(orderStatusLogsBean);
    sessionAttributes.put("String_Node_Str",orderStatusLogsEntity.getOrderItemId());
    orderStatusLogsEntity.setCreatedTimestamp(new Date());
    orderStatusLogsEntity.setCreatedBy(commonUtils.getUserNameFromSession());
    orderStatusLogsService.addStatus(orderStatusLogsEntity);
    OrderItems orderItemEntity=orderStatusLogsService.findOrderItemById((Integer)sessionAttributes.get("String_Node_Str"));
    orderItemEntity.setStatus(orderStatusLogsBean.getStatus());
    orderStatusLogsService.updateStatusOrderItem(orderItemEntity);
    Orders orderEntity=orderService.findOrdersById(orderIdParam);
    orderEntity.setOrderStatus(orderStatusLogsBean.getStatus());
    orderService.updateOrder(orderEntity);
  }
 catch (  Exception e) {
    addActionError("String_Node_Str");
    return INPUT;
  }
  return SUCCESS;
}

Fixed version (ground truth):
public String updateStatus(){
  Map sessionAttributes=ActionContext.getContext().getSession();
  try {
    OrderStatusLogs orderStatusLogsEntity=transformToOrderStatusLogsEntity(orderStatusLogsBean);
    sessionAttributes.put("String_Node_Str",orderStatusLogsEntity.getOrderItemId());
    orderStatusLogsEntity.setCreatedTimestamp(new Date());
    orderStatusLogsEntity.setCreatedBy(commonUtils.getUserNameFromSession());
    orderStatusLogsService.addStatus(orderStatusLogsEntity);
    OrderItems orderItemEntity=orderStatusLogsService.findOrderItemById((Integer)sessionAttributes.get("String_Node_Str"));
    orderItemEntity.setStatus(orderStatusLogsBean.getStatus());
    orderStatusLogsService.updateStatusOrderItem(orderItemEntity);
  }
 catch (  Exception e) {
    addActionError("String_Node_Str");
    return INPUT;
  }
  return SUCCESS;
}
Program: 144350
Project: 144350
Buggy source:
@Override public void prepare(){
  vendorShippingList=vendorService.findVendorsByCriteria("String_Node_Str","String_Node_Str",1);
  vendorTruckingList=vendorService.findVendorsByCriteria("String_Node_Str","String_Node_Str",1);
  vendorTypeList=parameterService.getParameterMap(ParameterConstants.VENDOR_TYPE);
  vendorClassList=parameterService.getParameterMap(ParameterConstants.VENDOR_CLASS);
  statusList=parameterService.getParameterMap(ParameterConstants.STATUS);
  portsList=parameterService.getParameterMap(ParameterConstants.PORTS);
  truckTypeList=parameterService.getParameterMap(ParameterConstants.TRUCK_TYPE);
  bookingNumSearchList=parameterService.getParameterMap(ParameterConstants.ORDER,ParameterConstants.BOOKING_SEARCH);
  containerSearchList=parameterService.getParameterMap(ParameterConstants.CONTAINER_SEARCH);
  containerSizeList=parameterService.getParameterMap(ParameterConstants.CONTAINERS,ParameterConstants.CONTAINER_SIZE);
  containerEirTypeList=parameterService.getParameterMap(ParameterConstants.CONTAINERS,ParameterConstants.EIR_TYPE);
  containerStatusList=parameterService.getParameterMap(ParameterConstants.CONTAINERS,ParameterConstants.CONTAINER_STATUS);
}

Fixed version (ground truth):
@Override public void prepare(){
  vendorShippingList=vendorService.findVendorsByCriteria("String_Node_Str","String_Node_Str",1);
  vendorTruckingList=vendorService.findVendorsByCriteria("String_Node_Str","String_Node_Str",1);
  vendorTypeList=parameterService.getParameterMap(ParameterConstants.VENDOR_TYPE);
  vendorClassList=parameterService.getParameterMap(ParameterConstants.VENDOR_CLASS);
  statusList=parameterService.getParameterMap(ParameterConstants.STATUS);
  portsList=parameterService.getParameterMap(ParameterConstants.PORTS);
  truckTypeList=parameterService.getParameterMap(ParameterConstants.TRUCK_TYPE);
  bookingNumSearchList=parameterService.getParameterMap(ParameterConstants.ORDER,ParameterConstants.BOOKING_SEARCH);
  containerSearchList=parameterService.getParameterMap(ParameterConstants.CONTAINER_SEARCH);
  containerSizeList=parameterService.getParameterMap(ParameterConstants.CONTAINERS,ParameterConstants.CONTAINER_SIZE);
  containerEirTypeList=parameterService.getParameterMap(ParameterConstants.CONTAINERS,ParameterConstants.EIR_TYPE);
  containerStatusList=parameterService.getParameterMap(ParameterConstants.CONTAINERS,ParameterConstants.CONTAINER_STATUS);
  vendorList=vendorService.findAllShippingVendor();
}
Program: 144351
Project: 144351
Buggy source:
public String deleteItem(){
  OrderItems orderItemEntity=orderService.findOrderItemByOrderItemId(orderItemIdParam);
  orderService.deleteItem(orderItemEntity);
  Orders orderEntityForm=orderService.findOrdersById(orderItemEntity.getOrderId());
  order=transformToOrderFormBean(orderEntityForm);
  Map sessionAttributes=ActionContext.getContext().getSession();
  customerItems=(List)sessionAttributes.get("String_Node_Str");
  List<OrderItems> orderItemEntityList=orderService.findAllItemByOrderId(orderItemEntity.getOrderId());
  for (  OrderItems orderItemElem : orderItemEntityList) {
    orderItems.add(transformToOrderItemsFormBean(orderItemElem));
  }
  clearErrorsAndMessages();
  addActionMessage("String_Node_Str");
  sessionAttributes.put("String_Node_Str",orderEntityForm.getOrderId());
  return SUCCESS;
}

Fixed version (ground truth):
public String deleteItem(){
  OrderItems orderItemEntity=orderService.findOrderItemByOrderItemId(orderItemIdParam);
  orderService.deleteItem(orderItemEntity);
  Orders orderEntityForm=orderService.findOrdersById(orderItemEntity.getOrderId());
  order=transformToOrderFormBean(orderEntityForm);
  Map sessionAttributes=ActionContext.getContext().getSession();
  customerItems=(List)sessionAttributes.get("String_Node_Str");
  List<OrderItems> orderItemEntityList=orderService.findAllItemByOrderId(orderItemEntity.getOrderId());
  for (  OrderItems orderItemElem : orderItemEntityList) {
    orderItems.add(transformToOrderItemsFormBean(orderItemElem));
  }
  if (orderItemEntityList.size() == 0) {
    orderEntityForm.setOrderStatus("String_Node_Str");
    orderService.updateOrder(orderEntityForm);
  }
  clearErrorsAndMessages();
  addActionMessage("String_Node_Str");
  sessionAttributes.put("String_Node_Str",orderEntityForm.getOrderId());
  return SUCCESS;
}