package mailinglist;
/**
 * A contact is a name and address.
 * <p>
 * For the purpose of this example, I have simplified matters 
 * a bit by making both of these components simple strings. 
 * In practice, we would expect Address, at least, to be a
 * more structured type.
 * 
 * @author zeil
 *
 */
public class Contact 
  implements Cloneable, Comparable<Contact> {

 private String theName;
 private String theAddress;

 /**
  * Create a contact with empty name and address.
  *
  */
 public Contact ()
 {
  theName = "";
  theAddress = "";
 }

 /**
  * Create a contact
  * @param nm  name 
  * @param addr address
  */
 public Contact (String nm, String addr)
 {
  theName = nm;
  theAddress = addr;
 }


 /**
  * Get the name of the contact
  * @return the name
  */
 public String getName()
 {
  return theName;
 }
 
 /**
  * Change the name of the contact
  * @param nm new name
  */
 public void setName (String nm) 
 {
  theName= nm;
 }

 /**
  * Get the address of the contact
  * @return the address
  */
 public String getAddress()
 {
  return theAddress;
 }
 
 /**
  * Change the address of the contact 
  * @param addr new address
  */
 public void setAddress (String addr) 
 {
  theAddress = addr;
 }

 /**
  * True if the names and addresses are equal 
  */
 public boolean equals (Object right)
 {
  Contact r = (Contact)right;
  return theName.equals(r.theName)
     && theAddress.equals(r.theAddress);
 }

 public int hashCode ()
 {
  return theName.hashCode() + 3 * theAddress.hashCode();
 }

 public String toString()
 {
  return theName + ": " + theAddress;
 }
 
 public Object clone()
 {
  return new Contact(theName, theAddress);
 }

 /**
  * Compare this contact to another.
  * Return value > 0 if this contact precedes the other,
  * == 0 if the two are equal, and < 0 if this contact
  * follows the other.  
  */
 public int compareTo (Contact c)
 {
  int nmcomp = theName.compareTo(c.theName);
  if (nmcomp != 0)
   return nmcomp;
  else
   return theAddress.compareTo(c.theAddress);
 }
}

package mailinglist;
/**
 * A contact is a name and address.
 * <p>
 * For the purpose of this example, I have simplified matters 
 * a bit by making both of these components simple strings. 
 * In practice, we would expect Address, at least, to be a
 * more structured type.
 * 
 * @author zeil
 *
 */
public class Contact 
  implements Cloneable, Comparable<Contact> {

 private String theName;
 private String theAddress;

 /**
  * Create a contact with empty name and address.
  *
  */
 public Contact ()
 {
  theName = "";
  theAddress = "";
 }

 /**
  * Create a contact
  * @param nm  name 
  * @param addr address
  */
 public Contact (String nm, String addr)
 {
  theName = nm;
  theAddress = addr;
 }


 /**
  * Get the name of the contact
  * @return the name
  */
 public String getName()
 {
  return theName;
 }
 
 /**
  * Change the name of the contact
  * @param nm new name
  */
 public void setName (String nm) 
 {
  theName= nm;
 }

 /**
  * Get the address of the contact
  * @return the address
  */
 public String getAddress()
 {
  return theAddress;
 }
 
 /**
  * Change the address of the contact 
  * @param addr new address
  */
 public void setAddress (String addr) 
 {
  theAddress = addr;
 }

 /**
  * True if the names and addresses are equal 
  */
 public boolean equals (Object right)
 {
  Contact r = (Contact)right;
  return theName.equals(r.theName)
     && theAddress.equals(r.theAddress);
 }

 public int hashCode ()
 {
  return theName.hashCode() + 3 * theAddress.hashCode();
 }

 public String toString()
 {
  return theName + ": " + theAddress;
 }
 
 public Object clone()
 {
  return new Contact(theName, theAddress);
 }

 /**
  * Compare this contact to another.
  * Return value > 0 if this contact precedes the other,
  * == 0 if the two are equal, and < 0 if this contact
  * follows the other.  
  */
 public int compareTo (Contact c)
 {
  int nmcomp = theName.compareTo(c.theName);
  if (nmcomp != 0)
   return nmcomp;
  else
   return theAddress.compareTo(c.theAddress);
 }
}

package mailinglist;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;

/**
 * A collection of names and addresses
 */
public class MailingList implements Cloneable, Iterable<Contact> {

    private LinkedList<Contact> theContacts;

    /**
	 * Create an empty mailing list
	 *
	 */
	public MailingList() {
	    theContacts = new LinkedList<Contact>();
	}

	/**
	 *  Add a new contact to the list. Contacts should be kept in ascending
	 *  order with no duplicates.
	 *  
	 *  @param contact new contact to add
	 */
	public void addContact(Contact contact) {
	    ListIterator<Contact> it = theContacts.listIterator();
	    while (it.hasNext()) {
	        Contact c = it.next();
	        int compared = c.compareTo(contact); 
	        if (compared > 0) {
	            it.previous();
	            it.add(contact);
	            return;
	        } else if (compared == 0) {
	            return;
	        }
	    }
	    theContacts.add(contact);
	}

	/**
	 *  Remove one matching contact 
	 *  @param contact remove a contact equal to contact
	 */
	public void removeContact(Contact contact) {
        ListIterator<Contact> it = theContacts.listIterator();
        while (it.hasNext()) {
            Contact c = it.next();
            int compared = c.compareTo(contact); 
            if (compared > 0) {
                return;
            } else if (compared == 0) {
                it.remove();
                return;
            }
        }
	}

	/**
	 * Remove a contact with the indicated name
	 * @param name name of contact to remove
	 */
	public void removeContact(String name) {
        ListIterator<Contact> it = theContacts.listIterator();
        while (it.hasNext()) {
            Contact c = it.next();
            int compared = c.getName().compareTo(name); 
            if (compared > 0) {
                return;
            } else if (compared == 0) {
                it.remove();
                return;
            }
        }
	}

	/**
	 * Search for contacts
	 * @param name name to search for
	 * @return true if a contact with an equal name exists
	 */
	public boolean contains(String name) {
        ListIterator<Contact> it = theContacts.listIterator();
        while (it.hasNext()) {
            Contact c = it.next();
            int compared = c.getName().compareTo(name); 
            if (compared > 0) {
                return false;
            } else if (compared == 0) {
                return true;
            }
        }
        return false;
	}

	/**
	 * Search for contacts
	 * @param name name to search for
	 * @return contact with that name if found, null if not found
	 */
	public Contact getContact(String name) {
        ListIterator<Contact> it = theContacts.listIterator();
        while (it.hasNext()) {
            Contact c = it.next();
            int compared = c.getName().compareTo(name); 
            if (compared > 0) {
                return null;
            } else if (compared == 0) {
                return c;
            }
        }
        return null;
	}

	/**
	 * combine two mailing lists
	 *
	 */
	public void merge(MailingList anotherList) {
		// For a quick merge, we will loop around, checking the 
		// first item in each list, and always copying the smaller
		// of the two items into result
		LinkedList<Contact> result = new LinkedList<Contact>();
		ListIterator<Contact> thisPos = theContacts.listIterator();
        ListIterator<Contact> otherPos = anotherList.theContacts.listIterator();
        while (thisPos.hasNext() && otherPos.hasNext()) {
            Contact thisContact = thisPos.next();
            Contact otherContact = otherPos.next();
            int comp = thisContact.compareTo(otherContact);
            if (comp == 0) {
                result.add(thisContact);
            } else if (comp < 0) {
                result.add(thisContact);
                otherPos.previous();
            } else {
                result.add(otherContact);
                thisPos.previous();
            }           
        }
        // Now, one of the two lists has been entirely copied. 
        // The other might still have stuff to copy. So we just copy
        // any remaining items from the two lists. Note that one of these
        // two loops will execute zero times.
        while (thisPos.hasNext()) {
            result.add(thisPos.next());
        }
        while (otherPos.hasNext()) {
            result.add(otherPos.next());
        }
        // Now result contains the merged list. Transfer that into this list.
		theContacts = result;
	}

	/**
	 * How many contacts in list?
	 */
	public int size() {
		return theContacts.size();
	}

	/**
	 * Return true if mailing lists contain equal contacts
	 */
	public boolean equals(Object anotherList) {
	    if (!(anotherList instanceof MailingList)) {
	        return false;
	    }
		MailingList right = (MailingList) anotherList;
		if (size() != right.size()) { // (easy test first!)
			return false;
		}
        ListIterator<Contact> thisPos = theContacts.listIterator();
        ListIterator<Contact> otherPos = right.theContacts.listIterator();
        while (thisPos.hasNext() && otherPos.hasNext()) {
            Contact thisContact = thisPos.next();
            Contact otherContact = otherPos.next();
            if (!thisContact.equals(otherContact)) {
                return false;
            }
        }
        return true;
	}

	public int hashCode() {
	    return theContacts.hashCode();
	}

	public String toString() {
		StringBuffer buf = new StringBuffer("{");
		boolean first = true;
		for (Contact c: theContacts) {
		    if (!first) {
		        buf.append(", ");
		    }
		    first = false;
		    buf.append(c.toString());
		}
		buf.append("}");
		return buf.toString();
	}

	/**
	 * Deep copy of contacts
	 */
	public Object clone() {
		MailingList result = new MailingList();
		for (Contact c: theContacts) {
		    result.theContacts.add((Contact)c.clone());
		}
		return result;
	}


	/**
	 * Provide access to the contacts.
	 */
    @Override
    public Iterator<Contact> iterator() {
        return theContacts.iterator();
    } 
	
}

package mailinglist;

import static org.junit.jupiter.api.Assertions.*;

import java.time.Duration;
import java.util.Arrays;

import org.hamcrest.core.IsNull;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

import static org.hamcrest.MatcherAssert.assertThat;                                                                    
import static org.hamcrest.Matchers.*;                                                                                  
import static org.junit.jupiter.api.Assertions.*;

class TestMailingList {
    
    Contact holmes;
    Contact adams;
    Contact baker;
    Contact charles;
    Contact dickens;
    Contact adams2;
    
    Contact[] inputs;

    MailingList ml;
    
    @BeforeEach
    void setup() {
        holmes = new Contact("Holmes", "21B baker St.");
        adams = new Contact("Adams", "21 Pennsylvania Ave.");
        baker = new Contact("Baker", "Drury Ln.");
        charles = new Contact("Charles", "100 1st St.");
        dickens = new Contact("Dickens", "200 2nd St.");
        adams2 = new Contact("Adams", "32 Pennsylvania Ave.");
        
        Contact[] order = {dickens, adams, charles, holmes, baker}; 
        inputs = order;
        
        ml = new MailingList();
    }

    @Test
    void testMailingList() {
        assertEquals (0, ml.size());
        assertFalse (ml.contains("Jones"));
        assertNull (ml.getContact("Smith"));
        MailingList ml2 = new MailingList();
        assertEquals (ml2, ml);
        assertEquals (ml2.hashCode(), ml.hashCode());
        assertNotNull(ml.toString());
    }

    @Test
    void testAddContact() {
        ml.addContact(holmes);
        assertEquals (1, ml.size());
        assertTrue(ml.contains("Holmes"));
        assertFalse(ml.contains("Jones"));
        assertEquals (holmes, ml.getContact("Holmes"));
        assertNull (ml.getContact("Jones"));
        assertNotEquals(ml, new MailingList());
        MailingList ml2 = new MailingList();
        ml2.addContact(holmes);
        assertEquals (ml2, ml);
        assertEquals (ml2.hashCode(), ml.hashCode());
        assertTrue(ml.toString().contains("Holmes"));
    }

    @ParameterizedTest
    @ValueSource(ints = {1, 2, 3, 4, 5})
    void testAddContactMulti(int testSize) {
        Contact[][] expected = {{dickens},
                {adams, dickens},
                {adams, charles, dickens},
                {adams, charles, dickens, holmes},
                {adams, baker, charles, dickens, holmes}
        };

        MailingList ml0 = (MailingList)ml.clone();
        for (int i = 0; i < testSize; ++i) {
            ml.addContact(inputs[i]);
        }
        assertEquals(testSize, ml.size());
        for (int j = 0; j <= testSize-1; ++j) {
            assertTrue (ml.contains(inputs[j].getName()));
            assertEquals (inputs[j], ml.getContact(inputs[j].getName()));
            assertTrue(ml.toString().contains(inputs[j].getName()));
        }
        for (int j = testSize; j < inputs.length; ++j) {
            assertFalse (ml.contains(inputs[j].getName()));
            assertNull (ml.getContact(inputs[j].getName()));
            assertFalse(ml.toString().contains(inputs[j].getName()));
        }
        assertNotEquals(ml, ml0);
        assertIterableEquals(Arrays.asList(expected[testSize-1]), ml);
    }   
 
    
    
    @Test
    void testAddDuplicateContact() {
        for (int i = 0; i < inputs.length; ++i) {
            ml.addContact(inputs[i]);
        }
        MailingList ml0 = (MailingList)ml.clone();
        
        // Add a duplicate
        ml.addContact(baker);
        assertThat(ml.size(), equalTo(ml0.size()));
        assertThat(ml, is(ml0));  // is() == equalTo()
        assertThat(ml.hashCode(), equalTo(ml0.hashCode()));
        assertTrue (ml.contains(baker.getName()));
        assertThat (ml.getContact(baker.getName()), equalTo(baker));
        assertTrue(ml.toString().contains(baker.getName()));
        
        Contact[] expected = {adams, baker, charles, dickens, holmes};
        assertThat(ml, contains(expected));       
    }   
    
    
    @Test
    void testRemoveContactContact() {
        for (int i = 0; i < inputs.length; ++i) {
            ml.addContact(inputs[i]);
        }
        MailingList ml0 = (MailingList)ml.clone();
        
        ml.removeContact(charles);
        Contact[] expected = {adams, baker, dickens, holmes};
        
        assertThat (ml.size(), is(ml0.size()-1));
        assertThat (ml, not(equalTo(ml0)));
        assertFalse (ml.contains(charles.getName()));
        assertNull (ml.getContact(charles.getName()));
        assertThat (ml, contains(expected));   
    }

    @Test
    void testRemoveContactString() {
        for (int i = 0; i < inputs.length; ++i) {
            ml.addContact(inputs[i]);
        }
        MailingList ml0 = (MailingList)ml.clone();
        
        ml.removeContact(dickens.getName());
        Contact[] expected = {adams, baker, charles, holmes};
        
        assertThat (ml.size(), is(ml0.size()-1));
        assertThat (ml, not(equalTo(ml0)));
        assertFalse (ml.contains(dickens.getName()));
        assertNull (ml.getContact(dickens.getName()));
        assertThat (ml, contains(expected));   
    }

    @Test
    void testMerge() {
        for (int i = 0; i < inputs.length; ++i) {
            ml.addContact(inputs[i]);
        }
        int divider = inputs.length / 2;
        MailingList ml1  = new MailingList();
        for (int i = 0; i <= divider; ++i) {
            ml1.addContact(inputs[i]);
        }
        MailingList ml2  = new MailingList();
        for (int i = divider; i < inputs.length; ++i) {
            ml2.addContact(inputs[i]);
        }
        
        MailingList ml0 = (MailingList)ml2.clone();
        
        ml1.merge(ml2);
        
        assertThat (ml1.size(), is(ml.size()));
        assertThat (ml1, equalTo(ml));
        assertThat (ml1.hashCode(), equalTo(ml.hashCode()));
        assertIterableEquals(ml1, ml);
        assertThat (ml1.toString(), equalTo(ml.toString()));
        
        assertThat (ml2.size(), is(ml0.size()));
        assertThat (ml2, equalTo(ml0));
        assertIterableEquals(ml2, ml0);
        
        for (int i = 0; i < inputs.length; ++i) {
            assertTrue (ml1.contains(inputs[i].getName()));
            assertThat (ml1.getContact(inputs[i].getName()), is(inputs[i]));
        }
        
        
        
    }

    @Test
    void testClone() {
        MailingList ml0 = new MailingList();
        for (int i = 0; i < inputs.length; ++i) {
            ml0.addContact(inputs[i]);
        }
        MailingList ml = (MailingList)ml0.clone();
        
        assertThat (ml.size(), is(ml0.size()));
        assertThat (ml, equalTo(ml0));
        assertThat (ml.hashCode(), equalTo(ml0.hashCode()));
        assertIterableEquals(ml, ml0);
        assertThat (ml.toString(), equalTo(ml0.toString()));
        
        // clone() should be a deep copy, so changing one list should
        // not affect the other.
        int size = ml.size();
        ml.removeContact(baker);
        
        assertThat (ml0.size(), is(size));
        assertThat (ml0, not(equalTo(ml)));
        assertTrue (ml0.contains(baker.getName()));
        assertThat (ml0.getContact(baker.getName()), equalTo(baker));
        assertThat (ml0.toString(), not(equalTo(ml.toString())));
        
        ml = (MailingList)ml0.clone();
        ml0.removeContact(baker);
        
        assertThat (ml.size(), is(size));
        assertThat (ml, not(equalTo(ml0)));
        assertTrue (ml.contains(baker.getName()));
        assertThat (ml.getContact(baker.getName()), equalTo(baker));
        assertThat (ml.toString(), not(equalTo(ml0.toString())));
        
        
    }

}

package mailinglist;
/**
 * A contact is a name and address.
 * <p>
 * For the purpose of this example, I have simplified matters 
 * a bit by making both of these components simple strings. 
 * In practice, we would expect Address, at least, to be a
 * more structured type.
 * 
 * @author zeil
 *
 */
public class Address implements Cloneable {

    private String name;
    private String streetAddress;
    private String city;
    private String state;
    private String zipCode;

    /**
     * Create an address with all empty fields.
     *
     */
    public Address ()
    {
        name = "";
        streetAddress = "";
        city = "";
        state = "";
        zipCode = "";
    }

    /**
     * Create an address.
     */
    public Address (String nm, String streetAddr, String city, 
            String state, String zip)
    {
        name = nm;
        streetAddress = streetAddr;
        this.city = city;
        this.state = state;
        zipCode = zip;
    }



    /**
     * @return the theName
     */
    public String getName() {
        return name;
    }

    /**
     * @param theName the theName to set
     */
    public void setName(String theName) {
        this.name = theName;
    }

    /**
     * @return the streetAddress
     */
    public String getStreetAddress() {
        return streetAddress;
    }

    /**
     * @param streetAddress the streetAddress to set
     */
    public void setStreetAddress(String streetAddress) {
        this.streetAddress = streetAddress;
    }

    /**
     * @return the city
     */
    public String getCity() {
        return city;
    }

    /**
     * @param city the city to set
     */
    public void setCity(String city) {
        this.city = city;
    }

    /**
     * @return the state
     */
    public String getState() {
        return state;
    }

    /**
     * @param state the state to set
     */
    public void setState(String state) {
        this.state = state;
    }

    /**
     * @return the zipCode
     */
    public String getZipCode() {
        return zipCode;
    }

    /**
     * @param zipCode the zipCode to set
     */
    public void setZipCode(String zipCode) {
        this.zipCode = zipCode;
    }

    /**
     * True if the names and addresses are equal 
     */
    public boolean equals (Object right)
    {
        Address r = (Address)right;
        return name.equals(r.name)
                && streetAddress.equals(r.streetAddress)
                && city.equals(r.city)
                && state.equals(r.state)
                && zipCode.equals(r.zipCode);
    }

    public int hashCode ()
    {
        return name.hashCode() + 3 * streetAddress.hashCode()
        + 5 * city.hashCode()
        + 7 * state.hashCode()
        + 11 * zipCode.hashCode();
    }

    public String toString()
    {
        return name + ": " + streetAddress + ": " 
                + city + ", " + state + " " + zipCode;
    }

    public Object clone()
    {
        return new Address(name, streetAddress, city,
                state, zipCode);
    }

}

#ifndef MAILINGLIST_H
#define MAILINGLIST_H

#include <iostream>
#include <string>

#include "contact.h"
#include "mlIterator.h"

/**
   A collection of names and addresses
*/
class MailingList
{
public:

  typedef MLConstIterator iterator;
  typedef MLConstIterator const_iterator;

  MailingList();
  MailingList(const MailingList&);
  ~MailingList();

  const MailingList& operator= (const MailingList&);

  // Add a new contact to the list
  void addContact (const Contact& contact);

  // Does the list contain this person?
  bool contains (const Name&) const;

  // Find the contact
  const Contact& getContact (const Name& nm) const;
  //pre: contains(nm)

  // Remove one matching contact
  void removeContact (const Contact&);
  void removeContact (const Name&);

  // combine two mailing lists
  void merge (const MailingList& otherList);

  // How many contacts in list?
  int size() const;


  bool operator== (const MailingList& right) const;
  bool operator< (const MailingList& right) const;

  // Provides iterator over contacts
  const_iterator begin() const;
  const_iterator end() const;


private:

  struct ML_Node {
    Contact contact;
    ML_Node* next;

    ML_Node (const Contact& c, ML_Node* nxt)
      : contact(c), next(nxt)
    {}
  };

  ML_Node* first;
  ML_Node* last;
  int theSize;

  // helper functions
  void clear();
  void remove (ML_Node* previous, ML_Node* current);

  friend std::ostream& operator<< (std::ostream& out, const MailingList& addr);
};

// print list, sorted by Contact
std::ostream& operator<< (std::ostream& out, const MailingList& list);


#endif

#include "mailinglist.h"

#include <string>
#include <vector>

#include "gtest/gtest.h"

namespace {

using namespace std;

// The fixture for testing class MailingList.
class MailingListTests : public ::testing::Test {  ➀
 public:
  Contact jones;                                 ➃
  MailingList mlist;

  virtual void SetUp() {
    jones = Contact("Jones", "21 Penn. Ave.");     ➄
    mlist = MailingList();
    mlist.addContact (Contact ("Baker", "Drury Ln."));
    mlist.addContact (Contact ("Holmes", "221B Baker St."));
    mlist.addContact (Contact ("Wolfe", "454 W. 35th St."));
  }

  virtual void TearDown() {
  }

};

TEST_F (MailingListTests, constructor) {
  MailingList ml;
  EXPECT_EQ (0, ml.size());                ➁
  EXPECT_FALSE (ml.contains("Jones"));
}


TEST_F (MailingListTests, addContact) {
  mlist.addContact (jones);                      ➅
  EXPECT_TRUE (mlist.contains("Jones"));         ➂
  EXPECT_EQ ("Jones", mlist.getContact("Jones").getName());
  EXPECT_EQ (4, ml.size());
}




}  // namespace

#define BOOST_TEST_MODULE MailingList test

#include "mailinglist.h"

#include <string>
#include <vector>

#include <boost/test/included/unit_test.hpp>

using namespace std;

// The fixture for testing mailing lists.
class MailingListTests  {                        ➀
 public:
  Contact jones;                                 ➁
  MailingList mlist;

  MailingListTests() {                           ➃
    jones = Contact("Jones", "21 Penn. Ave.");
    mlist.addContact (Contact ("Baker", "Drury Ln."));
    mlist.addContact (Contact ("Holmes", "221B Baker St."));
    mlist.addContact (Contact ("Wolfe", "454 W. 35th St."));
  }

  ~MailingListTests() {
  }

};

BOOST_AUTO_TEST_CASE ( constructor ) {         ➄
  MailingList ml;
  BOOST_CHECK_EQUAL (0, mlist.size());            ➅
  BOOST_CHECK (!mlist.contains("Jones"));
}


BOOST_FIXTURE_TEST_CASE (addContact, MailingListTests) { ➆
  mlist.addContact (jones);                         ➂
  BOOST_CHECK (mlist.contains("Jones"));           
  BOOST_CHECK_EQUAL ("Jones", mlist.getContact("Jones").getName());
  BOOST_CHECK_EQUAL (4, mlist.size());
}

#include "unittest.h"     ➀
#include "mailinglist.h"

#include <string>
#include <vector>

using namespace std;

Contact jones;
MailingList mlist;

void setUp()
{
	jones = Contact("Jones", "21 Penn. Ave.");
	mlist = MailingList();
	mlist.addContact (Contact ("Baker", "Drury Ln."));
	mlist.addContact (Contact ("Holmes", "221B Baker St."));
	mlist.addContact (Contact ("Wolfe", "454 W. 35th St."));
}



UnitTest (constructor) {    ➁
	MailingList ml;
	assertThat (ml.size(), is(0));      ➂
	assertFalse (ml.contains("Jones"));
}


UnitTest (addContact) {
	setup();                     ➃
	mlist.addContact (jones);
	assertTrue (mlist.contains("Jones"));
	assertThat (mlist.getContact("Jones").getName(), is("Jones"));
	assertThat (ml.size(), is(4));
	assertThat (ml, hasItem(jones));  ➄
}