Respan Dataset Explorer

import java.util.ArrayList;

enum TREETYPE { BST, AVL, SPLAY
};

public class WirelessPower {
    public int DEFAULT_HEIGHT = 0;
    public int DEFAULT_ID = 0;
    public int MINID = 10000;
    public int MAXID = 99999;
    public int MINLAT = -90;
    public int MAXLAT = 90;
    public int MINLONG = -180;
    public int MAXLONG = 180;

    /**
     * The constructor performs the required initializations. It creates an empty
     * object. It also
     * specifies the type of the tree. The tree can be a regular BST which does not
     * perform any
     * re-structuring. It can be an AVL tree which re-balances the tree after every
     * insertion or removal.
     * The third type is a Splay tree which splays the accessed node to the tree
     * root.
     * 
     * @param type one of the enumerators ot TREETYPE
     */
    public WirelessPower(TREETYPE type) {
        this.m_type = type; // Initalize m_type to type of tree
        m_root = null; // Initalzing root of the tree to null
    }

    /**
     * @return the enumerated type of TREETYPE
     */
    TREETYPE getType() {

        return m_type; // returning the type of tree.
    }

    /**
     * Copy constructor for WirelessPower
     */
    public WirelessPower(WirelessPower rhs) {
        // Copying the type of tree
        m_type = rhs.m_type;
        // Deep copy of the tree.
        m_root = copyOfTree(rhs.m_root);
    }

    /**
     * This function inserts a Customer object into the tree in the proper position.
     * The Customer::m_id should be used as the key to traverse the WirelessPower
     * tree
     * and abide by BST traversal rules. The comparison operators (>, <, ==, !=)
     * work with
     * the int type in C++. A Customer id is a unique number in the range MINID -
     * MAXID.
     * We do not allow a duplicate id or an object with invalid id in the tree.
     * Note:
     * • In the WirelessPower tree data structure every node is a Customer object
     * which is
     * represented as a pointer to the Customer object. Therefore, for every
     * insertion we
     * need to allocate memory and use the information of customer to initialize the
     * new node.
     * Memory allocation takes place in the WirelessPower class.
     * • If the tree type is BST, after an insertion, we should update the height
     * for all nodes
     * in the insertion path.
     * • If the tree type is AVL, after an insertion, we should update the height of
     * each node in
     * the insertion path as well as check for an imbalance at each node in this
     * path.
     * • If the tree type is SPLAY, after and insertion, we need to splay the
     * inserted node
     * and bring it to the root of the tree while the tree preserves the BST
     * property as well as updating the node heights.
     */
    // aCustomer here is the ID..
    public void insert(Customer aCustomer) {

        // Check for valid range of ID
        if (aCustomer.getID() < MINID || aCustomer.getID() > MAXID) {
            return;
        }

        // Check if tree is empty
        if (isEmpty()) {
            // Create a new customer node and set it as the root since tree is empty
            m_root = new Customer(aCustomer.getID(), aCustomer.getLatitude(), aCustomer.getLongitude());

            return;
        }
        // To determine which type of insertion to use / rebalance as well
        switch (getType()) {
            case BST:
                m_root = insertBST(m_root, aCustomer);
                break;
            case AVL:
                m_root = insertAVL(m_root, aCustomer);

                break;
            case SPLAY:
                m_root = insertSplay(m_root, aCustomer);
                break;
        }

    }

    /**
     * The clear function makes it an empty tree.
     */
    public void clear() {
        m_root = null;
    }

    /**
     * The remove function traverses the tree to find a node with the id and removes
     * it from the tree. In the case of BST or AVL tree the remove function should
     * also update
     * the heights for all nodes in the removal path. If the tree type is SPLAY, the
     * remove
     * function does not remove the node.
     */
    public void remove(int id) {

        switch (getType()) {
            case BST:
                m_root = deleteRecursively(m_root, id);
                break;
            case AVL:
                m_root = deleteRecursively(m_root, id);
                break;
            case SPLAY:
                // Do nothing if SPLAY tree
                break;
        }
    }

    /**
     * This function sets the type of an existing WirelessPower object. Once the
     * type is changed,
     * the function should re-structure the tree according to the following rules:
     * • If the type is changed from BST or SPLAY to AVL, the function should
     * reconstruct the
     * tree as an AVL tree. In the case of reconstruction the nodes are transferred
     * from the
     * old tree to the new tree. There should not be any reallocation of memory.
     * • If the type is changed from AVL to BST or Splay, there is no need for
     * reconstruction.
     * After change the tree operations will perform according to the new type.
     * • Any change between BST and SPLAY types will not trigger a reconstruction.
     * After
     * change the tree operations will perform according to the new type.
     */
    public void setType(TREETYPE type) {
        // If the new type is the same as current just return
        // Nothing to do.
        if (m_type == type) {
            return;
        }

        switch (m_type) {
            // AVL doesn't need to be reconstructed to BST or SPLAY
            case AVL:
                // Just update the variable to tree type instead.
                if (type == TREETYPE.BST || type == TREETYPE.SPLAY) {
                    m_type = type; // Update the type
                }
                break;
            case BST:
                if (type == TREETYPE.AVL) {
                    BstToAVL();
                    m_type = type;
                } else {
                    m_type = type;
                }
                break;
            case SPLAY:
                if (type == TREETYPE.AVL) {
                    BstToAVL();
                    m_type = type;
                }
                break;
            default:
                break;
        }
    }

    /**
     * creates an exact deep copy of the rhs.
     */
    public Customer copy(WirelessPower rhs) {
        // Create a new customer root to hold for the copy of tree
        // But first check if it's empty.
        if (rhs.m_root == null) {
            return null;
        }
        // Copying the nodes recursively.
        Customer nRoot = copyOfTree(rhs.m_root);
        return nRoot;
    }

    public String dumpTree() {
        String result = "";
        result = dump(m_root, result);
        return result;
    }

    public String dump(Customer aCustomer, String result) {
        if (aCustomer == null) {
            return result;
        }
        // System.out.print("Customer: "+aCustomer.getID()+" result: "+result);
        result += "(";
        result = dump(aCustomer.m_left, result);// first visit the left child
        result += aCustomer.m_id + ":" + aCustomer.m_height;// second visit the node itself
        result = dump(aCustomer.m_right, result);// third visit the right child
        result += ")";
        return result;
    }

    // ***********************************************************************************************
    // Used for testing - provided for you
    // ***********************************************************************************************
    public Customer getRoot() {
        return m_root;
    }

    public String listCustomers() {
        String result = "";
        result = list(m_root, result);
        return result.trim();
    }

    private String list(Customer aCustomer, String result) {
        if (aCustomer == null) {
            return result;
        }
        // System.out.println("Customer: " + aCustomer.getID() + " result: " + result);
        result = list(aCustomer.m_left, result);// first visit the left child
        // second visit the node itself
        result += aCustomer.m_id + ":" + aCustomer.getLatitude() + ":" + aCustomer.getLongitude() + "\n";
        result = list(aCustomer.m_right, result);// third visit the right child
        return result;
    }

    private Customer m_root; // the root of the BST
    private TREETYPE m_type; // the type of tree, BST, AVL or SPLAY

    // ***************************************************
    // Any private helper functions must be delared here!
    // ***************************************************

    // Function to check if tree is empty.
    private boolean isEmpty() {
        return m_root == null;
    }

    // Helper function to recursively copy a tree structure
    private Customer copyOfTree(Customer node) {
        // Base case
        if (node == null) {
            return null;
        }
        // Creating a new customer with the same properties..
        Customer newCustomer = new Customer(node.getID(), node.getLatitude(), node.getLongitude());

        // Recursively copy the left and right child
        newCustomer.setLeft(copyOfTree(node.getLeft()));
        newCustomer.setRight(copyOfTree(node.getRight()));
        // Also copying the height
        newCustomer.setHeight((node.getHeight()));

        return newCustomer;
    }

    // Calculate balance factor.
    private int getBalance(Customer node) {
        // Base case
        if (node == null) {
            return 0;
        }
        int leftHeight = -1;
        int rightHeight = -1;

        // Getting height of left and right child
        // Then left - right for balance factor.
        if (node.getLeft() != null) {
            leftHeight = node.getLeft().getHeight();
        }

        if (node.getRight() != null) {
            rightHeight = node.getRight().getHeight();
        }

        return leftHeight - rightHeight;
    }

    // AVL Balance
    private Customer balance(Customer node) {
        int balanceFactor = getBalance(node);

        // Left Right
        if (balanceFactor > 1 && getBalance(node.getLeft()) < 0) {
            node.setLeft(leftRotate(node.getLeft()));
            return rightRotate(node);
        }
        // Left Left
        if (balanceFactor > 1 && getBalance(node.getLeft()) >= 0) {
            return rightRotate(node);
        }
        // Right Left
        if (balanceFactor < -1 && getBalance(node.getRight()) > 0) {
            node.setRight(rightRotate(node.getRight()));
            return leftRotate(node);
        }
        // Right right
        if (balanceFactor < -1 && getBalance(node.getRight()) <= 0) {
            return leftRotate(node);
        }

        return node;
    }

    // Perform right rotation for AVL tree.
    private Customer rightRotate(Customer y) {
        // Making x the new root of the subtree.
        Customer x = y.getLeft();
        // Storing the right child of x.
        Customer temp = x.getRight();

        // Rotate to ->
        // y becomes the right child of x
        x.setRight(y);
        // temp(the right child of x) becomes the left child
        // Of y
        y.setLeft(temp);

        // Now we update the heights.
        updateHeight(y);
        updateHeight(x);

        // New root
        return x;
    }

    // Perform left rotation for AVL tree.
    private Customer leftRotate(Customer y) {
        // Making x the new root of the subtree.
        Customer x = y.getRight();
        // Storing the left child of x
        Customer temp = x.getLeft();

        // Rotate to <-
        // y become the left child of x.
        x.setLeft(y);
        // temp(the left child of x) becomes the right child
        // Of Y
        y.setRight(temp);

        // Update height
        updateHeight(y);
        updateHeight(x);

        return x;
    }

    // Rotate function for splay to the left.
    private Customer leftRotateSplay(Customer x) {

        // No rotation possible for these two cases
        if (x == null) {
            return x;
        }

        if (x.getRight() == null) {
            return x;
        }
        // Y is the new root after totation
        Customer y = x.getRight();
        // Move the left child of y to be the right child of x
        x.setRight(y.getLeft());
        // Rotatiing here
        y.setLeft(x);

        updateHeight(x);
        updateHeight(y);
        return y;
    }

    // Rotate function for splay to the right
    private Customer rightRotateSplay(Customer x) {
        // No rotation possible for these two cases
        if (x == null) {
            return x;
        }

        if (x.getLeft() == null) {
            return x;
        }

        // Y is the new root after rotation
        Customer y = x.getLeft();
        // Move the right child of y to be the left child of x
        x.setLeft(y.getRight());
        // Rotating here
        y.setRight(x);

        updateHeight(x);
        updateHeight(y);
        return y;
    }

    // Updates the height of tree.
    private void updateHeight(Customer node) {
        // Check for null node
        if (node == null) {
            return;
        }

        // heights for left and right children
        // -1 if null which would be default
        int leftHeight = -1;
        int rightHeight = -1;

        // Check if left child is not null and get its height
        if (node.getLeft() != null) {
            leftHeight = node.getLeft().getHeight();
        }

        // Check if right child is not null and get its height
        if (node.getRight() != null) {
            rightHeight = node.getRight().getHeight();
        }

        node.setHeight(Math.max(leftHeight, rightHeight) + 1);
    }


    // Deletes nodes from a tree recursively.
    private Customer deleteRecursively(Customer node, int id) {
        // Base case
        if (node == null) {
            return null;
        }

        // Traversing the tree
        if (id < node.getID()) {
            // Go left
            node.setLeft(deleteRecursively(node.getLeft(), id));
        } else if (id > node.getID()) {
            // Go right
            node.setRight(deleteRecursively(node.getRight(), id));
        } else {
            // We found the node here we need to delete
           // System.out.println("Deleting node with ID: " + id);
            if (node.getLeft() == null) {
                // No left child so return the right
                return node.getRight();
            } else if (node.getRight() == null) {
                // No right child so return the left
                return node.getLeft();
            }
            // Node with two children replacing the min from the right subtree.
            Customer successor = findMin(node.getRight());
            // Replacing ID with the successor's ID
            node.setID(successor.getID());
            // Remove the successor
            node.setRight(deleteRecursively(node.getRight(), successor.getID()));
        }

        updateHeight(node);
        return balance(node);
    }

    // Help find the mininum
    private Customer findMin(Customer node) {
        // Go to the left most child in tree (Min)
        while (node.getLeft() != null) {
            node = node.getLeft();
        }
        return node;
    }

    public void BstToAVL() {
        // Creating an ArrayList to hold the nodes in sorted order
        ArrayList<Customer> nodeList = new ArrayList<>();

        // Filling the ArrayList with nodes in sorted order
        traverseInOrder(m_root, nodeList);

        // Converting the ArrayList to an AVL tree
        m_root = arrayToAVL(nodeList, 0, nodeList.size() - 1);
    }

    // Recursively build the AVL tree subtrees
    private Customer arrayToAVL(ArrayList<Customer> nodeList, int start, int end) {
        // No elements left in our tree
        if (start > end) {
            return null;
        }
        // Find the middle of the ArrayList.
        int mid = (start + end) / 2;
        // Create a root node
        Customer node = nodeList.get(mid);

        // Create the left subtree
        node.setLeft(arrayToAVL(nodeList, start, mid - 1));
        // Create the right subtree
        node.setRight(arrayToAVL(nodeList, mid + 1, end));

        return node;
    }

    // Traverse tree in order (Left subtree then root, then right subtree)
    // While storing the values into our ArrayList.
    private void traverseInOrder(Customer node, ArrayList<Customer> nodeList) {
        // If node is null, no nodes left
        if (node == null) {
            return;
        }
        // Traverse left of subtree first
        traverseInOrder(node.getLeft(), nodeList);
        // Add the current node to our ArrayList
        nodeList.add(node);
        // Traverse right of subtree afterwards
        traverseInOrder(node.getRight(), nodeList);
    }

    private Customer insertBST(Customer node, Customer aCustomer) {
        
        // Base case if the node is null create a new customer
        if (node == null) {
            return new Customer(aCustomer.getID(), aCustomer.getLatitude(), aCustomer.getLongitude());
        }

        // If key already in the tree return the node.
        // No Duplicates.
        if (node.getID() == aCustomer.getID()) {
            return node;
        }

        // Down the tree..
        if (aCustomer.getID() < node.getID()) {
            node.setLeft(insertBST(node.getLeft(), aCustomer));
        } else {
            node.setRight(insertBST(node.getRight(), aCustomer));
        }

        // Update height of the node after insertion
        updateHeight(node);

        return node;
    }

    // AVL Insertion
    private Customer insertAVL(Customer node, Customer aCustomer) {
        if (node == null) {
            return new Customer(aCustomer.getID(), aCustomer.getLatitude(), aCustomer.getLongitude());
        }

        if (node.getID() == aCustomer.getID()) {
            return node;
        }
        // Down the tree..
        if (aCustomer.getID() < node.getID()) {
            node.setLeft(insertAVL(node.getLeft(), aCustomer));
        } else {
            node.setRight(insertAVL(node.getRight(), aCustomer));
        }
        // Update the height of the ancestor node
        updateHeight(node);
        return balance(node);
    }

    //insert splay
private Customer insertSplay(Customer node, Customer aCustomer) {
    // Insert the node using insertBST and get the updated subtree root
    node = insertBST(node, aCustomer);

    // Perform splay operation starting from the current root
    node = splay(node, aCustomer);

    // Return the new root after splaying
    return node;
}
    private Customer splay(Customer node, Customer aCustomer) {
        // Base case if node is null or id is found
        if (node == null || node.getID() == aCustomer.getID()) {
            return node;
        }
    
        // Our ID is in the left subtree
        if (aCustomer.getID() < node.getID()) {
            // If left child is null return node
            if (node.getLeft() == null) {
                return node;
            }

            // Zig-Zig (Left Left)
            if (aCustomer.getID() < node.getLeft().getID()) {
                // splay the left left grandchild
                node.getLeft().setLeft(splay(node.getLeft().getLeft(), aCustomer));
                // perform first right rotation
                node = rightRotateSplay(node);
            }
            // Zig-Zag (Left Right)
            else if (aCustomer.getID() > node.getLeft().getID()) {
                // splay the left right grandchild
                node.getLeft().setRight(splay(node.getLeft().getRight(), aCustomer));
                // perform left rotation on left child
                if (node.getLeft().getRight() != null) {
                    node.setLeft(leftRotateSplay(node.getLeft()));
                }
            }
    
            //second right rotation if needed
            if (node.getLeft() == null) {
                return node;
            } else {
                // Final rotation
                node = rightRotateSplay(node);
                return node;
            }
        } else {
            // Our id in the right subtree
            // If right child is null return node
            if (node.getRight() == null) {
                return node;
            }
            
            // Right-Right (Zig-Zig)
            if (aCustomer.getID() > node.getRight().getID()) {
                //splay the right-right grandchild
                node.getRight().setRight(splay(node.getRight().getRight(), aCustomer));
                // First rotation
                node = leftRotateSplay(node);
            }
            // Right-Left (Zig-Zag)
            else if (aCustomer.getID() < node.getRight().getID()) {
                // splay the right-left grandchild
                node.getRight().setLeft(splay(node.getRight().getLeft(), aCustomer));
                //right rotation on right child
                if (node.getRight().getLeft() != null) {
                    node.setRight(rightRotateSplay(node.getRight()));
                }
            }
            
            // Second rotation
            if (node.getRight() == null) {
                return node;
            } else {
                // Final rotation
                node = leftRotateSplay(node);
                return node;
            }
        }
    }

    class Customer {
        int DEFAULT_HEIGHT = 0;
        int DEFAULT_ID = 0;
    
        Customer(int id, double lat, double longitude){
            m_id = id; m_latitude = lat; m_longitude = longitude;
            m_left = null; m_right = null; m_height = DEFAULT_HEIGHT;
        }
        //used for testing that ids are put in trees correctly
        Customer(int id){
            m_id = id; m_latitude = 0; m_longitude = 0;
            m_left = null; m_right = null; m_height = DEFAULT_HEIGHT;

        }
        int getHeight() {return m_height;}
        Customer getLeft() {return m_left;}
        Customer getRight() {return m_right;}
        int getID() {return m_id;}
        double getLatitude() {return m_latitude;}
        double getLongitude() {return m_longitude;}
        void setID(int id){m_id=id;}
        void setLatitude(double lat) {m_latitude=lat;}
        void setLongitude(double longitude) {m_longitude=longitude;}
        void setHeight(int height){m_height=height;}
        void setLeft(Customer left){m_left=left;}
        void setRight(Customer right){m_right=right;}
        String getLatStr() {
            String text = "";
            int latSeconds = (int)(Math.abs(m_latitude * 3600));
            int latDegrees = latSeconds / 3600;
            latSeconds = latSeconds % 3600;
            int latMinutes = latSeconds / 60;
            latSeconds %= 60;
            char latDirection = (m_latitude >= 0) ? 'N' : 'S';
            text = Integer.toString(latDegrees) + "\u00B0 " + Integer.toString(latMinutes) + "' " + 
                    Integer.toString(latSeconds) + "\" " + latDirection;
            return text;
        }
        String getLongStr() {
            String text = "";
            int longSeconds = (int)(Math.abs(m_longitude * 3600));
            int longDegrees = longSeconds / 3600;
            longSeconds = longSeconds % 3600;
            int longMinutes = longSeconds / 60;
            longSeconds %= 60;
            char longDirection = (m_longitude >= 0) ? 'E' : 'W';
            text = Integer.toString(longDegrees) + "\u00B0 " + Integer.toString(longMinutes) + "' " + 
                    Integer.toString(longSeconds) + "\" " + longDirection;
            return text;
        }
    
        //private data members
        private int m_id;
        private double m_latitude;
        private double m_longitude;
        private Customer m_left;    //the pointer to the left child in the BST
        private Customer m_right;   //the pointer to the right child in the BST
        private int m_height;        //the height of node in the BST
        
    } // end of class Customer
} //end of class WirelessPower
 
Given this code 

how would you write a test case for this criteria 
Test the assignment operator for a normal case.

To test the assignment operator (simulated via the copy constructor) for the `WirelessPower` class in a normal case, we'll perform the following steps:

1. **Create an Original `WirelessPower` Object:**
   - Instantiate a `WirelessPower` object with a specific tree type (e.g., AVL).
   - Insert a set of `Customer` objects into the tree.

2. **Create a Copy Using the Copy Constructor:**
   - Use the copy constructor to create a new `WirelessPower` object that is a deep copy of the original.

3. **Verify the Integrity of the Copy:**
   - Ensure that the copied tree has the same structure and data as the original.
   - Modify the original tree and verify that the copy remains unaffected, confirming a deep copy.

4. **Assertions:**
   - Use assertions to compare the `dumpTree` or `listCustomers` outputs of both trees to ensure they are identical immediately after copying.
   - Further assertions can confirm that changes to one tree do not impact the other.

Below is a detailed example using **JUnit 5** to perform this test:

### Step 1: Setting Up the Test Environment

Ensure that you have JUnit 5 included in your project dependencies. If you're using Maven, add the following to your `pom.xml`:

```xml
<dependencies>
    <!-- Other dependencies -->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-engine</artifactId>
        <version>5.9.3</version>
        <scope>test</scope>
    </dependency>
</dependencies>
```

### Step 2: Writing the Test Case

```java
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;

public class WirelessPowerTest {

    @Test
    public void testCopyConstructor_NormalCase() {
        // Step 1: Create original WirelessPower object with AVL tree type
        WirelessPower original = new WirelessPower(WirelessPower.TREETYPE.AVL);
        
        // Insert multiple Customers
        original.insert(new WirelessPower.Customer(15000, 34.0522, -118.2437)); // Los Angeles
        original.insert(new WirelessPower.Customer(20000, 40.7128, -74.0060));  // New York
        original.insert(new WirelessPower.Customer(17500, 37.7749, -122.4194)); // San Francisco
        original.insert(new WirelessPower.Customer(12500, 47.6062, -122.3321)); // Seattle
        original.insert(new WirelessPower.Customer(22500, 41.8781, -87.6298));  // Chicago
        
        // Step 2: Create a copy using the copy constructor
        WirelessPower copy = new WirelessPower(original);
        
        // Step 3: Verify that both trees have the same dumpTree output
        String originalDump = original.dumpTree();
        String copyDump = copy.dumpTree();
        assertEquals(originalDump, copyDump, "The copied tree should have the same structure and data as the original.");
        
        // Additionally, verify listCustomers outputs are identical
        String originalList = original.listCustomers();
        String copyList = copy.listCustomers();
        assertEquals(originalList, copyList, "The list of customers in the copied tree should match the original.");
        
        // Step 4: Modify the original tree
        original.insert(new WirelessPower.Customer(30000, 29.7604, -95.3698)); // Houston
        
        // Step 5: Ensure the copy does not reflect the change
        String modifiedOriginalDump = original.dumpTree();
        String unmodifiedCopyDump = copy.dumpTree();
        assertNotEquals(modifiedOriginalDump, unmodifiedCopyDump, "Modifying the original tree should not affect the copy.");
        
        String modifiedOriginalList = original.listCustomers();
        String unmodifiedCopyList = copy.listCustomers();
        assertNotEquals(modifiedOriginalList, unmodifiedCopyList, "Modifying the original list of customers should not affect the copy.");
        
        // Also, verify that the copy still contains the initial customers
        assertTrue(copy.listCustomers().contains("15000:34.0522:-118.2437"));
        assertTrue(copy.listCustomers().contains("20000:40.7128:-74.0060"));
        assertTrue(copy.listCustomers().contains("17500:37.7749:-122.4194"));
        assertTrue(copy.listCustomers().contains("12500:47.6062:-122.3321"));
        assertTrue(copy.listCustomers().contains("22500:41.8781:-87.6298"));
        
        // And the copy does NOT contain the new customer
        assertFalse(copy.listCustomers().contains("30000:29.7604:-95.3698"));
    }
}
```

### Explanation of the Test Case

1. **Creating the Original Tree:**
   - An `AVL` type `WirelessPower` tree named `original` is created.
   - Five `Customer` objects with unique IDs and distinct latitude and longitude values are inserted. These represent different cities for clarity.

2. **Copying the Tree:**
   - A new `WirelessPower` object named `copy` is created using the copy constructor, passing `original` as the argument. This should result in `copy` being an exact deep copy of `original`.

3. **Verifying the Copy:**
   - **Structure and Data Integrity:**
     - The `dumpTree` method's output for both `original` and `copy` should be identical, indicating the same tree structure and data.
     - Similarly, `listCustomers` should produce the same listing of customers for both trees.
   
   - **Independence of the Trees:**
     - After inserting a new `Customer` into `original`, the `copy` should remain unchanged. This is verified by ensuring that the `dumpTree` and `listCustomers` outputs of `copy` do not reflect the new insertion in `original`.
   
   - **Content Verification:**
     - The test also explicitly checks that all initially inserted customers are present in the `copy`.
     - It ensures that the new customer added only exists in the `original` and not in the `copy`, confirming the deep copy behavior.

### Running the Test

To execute the test, you can use your IDE's built-in JUnit support or run it via the command line using Maven:

```bash
mvn test
```

### Important Considerations

- **Access Modifiers:**
  - The `Customer` class is defined as an inner class within `WirelessPower`. Ensure that it has the appropriate access modifiers (e.g., `public` or package-private) to allow instantiation within the test class. If it's `private`, you might need to adjust its visibility for testing purposes.

- **Equality Checks:**
  - This test uses `dumpTree` and `listCustomers` methods to verify tree equality. Ensure these methods accurately represent the tree's structure and data. Alternatively, you could implement `equals` methods for both `WirelessPower` and `Customer` classes for more precise comparisons.

- **Deep Copy Verification:**
  - The test verifies that modifications to the original do not affect the copy, ensuring that a deep copy was performed. This is crucial to prevent unintended side effects in applications using the `WirelessPower` class.

By following this test case, you can confidently verify that the assignment (copy constructor) for the `WirelessPower` class works correctly under normal conditions.

Les citations chrétienne avec le mot aime 

Voici quelques citations chrétiennes qui incluent le mot "aime" :

1. **Jean 13:34-35** : « Je vous donne un commandement nouveau : Aimez-vous les uns les autres ; comme je vous ai aimés, vous aussi, aimez-vous les uns les autres. À ceci tous connaîtront que vous êtes mes disciples, si vous avez de l’amour les uns pour les autres. »

2. **1 Jean 4:7** : « Bien-aimés, aimons-nous les uns les autres, car l’amour est de Dieu ; et quiconque aime est né de Dieu et connaît Dieu. »

3. **Matthieu 22:37-39** : « Jésus lui répondit : ‘Tu aimeras le Seigneur ton Dieu de tout ton cœur, de toute ton âme et de tout ton esprit.’ C'est le premier et le plus grand commandement. Et voici le second, qui lui est semblable : ‘Tu aimeras ton prochain comme toi-même.’ »

4. **Romains 13:10** : « L'amour ne fait aucun mal au prochain ; l'amour est donc l'accomplissement de la loi. »

5. **1 Corinthiens 13:4-7** : « L'amour est patient, l'amour est plein de bonté ; l'amour n'envie point, il ne se vante point, ne s'enfle point d'orgueil, il ne fait rien de malhonnête, il ne cherche point son intérêt, il ne s'irrite point, il ne soupçonne point le mal ; il ne se réjouit point de l'injustice, mais il se réjouit de la vérité. Il excuse tout, il croit tout, il espère tout, il supporte tout. »

Ces versets soulignent l’importance de l’amour dans la foi chrétienne et ses implications dans les relations interpersonnelles.

Il semble que votre dernier message ne contenait pas de contenu. Si vous avez une question ou un sujet spécifique dont vous aimeriez discuter concernant les citations chrétiennes ou tout autre sujet, n'hésitez pas à le préciser ! Je suis là pour vous aider.

Les citations avec le mot aime 

Voici quelques citations célèbres qui incluent le mot "aime" :

1. **"Aime la vie que tu vis. Vis la vie que tu aimes."** – Bob Marley
2. **"On n'aime que ce que l'on connaît."** – Jean-Paul Sartre
3. **"Aimez-vous les uns les autres."** – Citation biblique
4. **"Aime-toi toi-même et tout le reste suivra."** – Lucille Ball
5. **"Aimez ce que vous faites, et vous n'aurez jamais à travailler un seul jour de votre vie."** – Confucius (attribué)

Ces citations expriment des idées sur l'amour, l'estime de soi et la passion pour la vie. Si vous cherchez des citations dans un autre contexte ou style, faites-le moi savoir !

Des citations plus rare avec le mot aime 

Voici quelques citations moins courantes mais intéressantes qui incluent le mot "aime" :

1. **"L'âme qui aime est une âme qui vit."** – Victor Hugo

2. **"Aime ce que tu fais et fais ce que tu aimes, mais souviens-toi que l'amour doit d'abord venir de toi-même."** – Anonyme

3. **"Aime chaque détail de ta vie, car c'est une toile sur laquelle tu peins ton bonheur."** – Anonyme

4. **"Aime et respecte-toi suffisamment pour ne jamais te contenter de moins que ce que tu mérites."** – Anonyme

5. **"Celui qui aime est toujours jeune."** – Proverbe espagnol

Ces citations mettent en avant l'idée que l'amour est fondamental pour notre existence et notre bien-être. Si vous souhaitez explorer d'autres thèmes ou trouver des citations dans un autre style, n'hésitez pas à demander !

qual elemento winui3 eu uso para visulizar uma lista de arquivos onde tem várias colunas

Para exibir uma lista de arquivos com várias colunas no WinUI 3, você tem algumas opções de controles que podem atender a essa necessidade. A escolha depende do nível de funcionalidade e personalização que você deseja. Abaixo estão as principais abordagens:

### 1. **ListView com Grid ou StackPanel no DataTemplate**

O controle `ListView` é altamente personalizável e pode ser configurado para exibir múltiplas colunas usando um `Grid` ou `StackPanel` dentro do `DataTemplate` dos itens. Isso permite que você defina exatamente como cada coluna deve ser apresentada.

**Exemplo:**

```xml
<ListView ItemsSource="{x:Bind Files}">
    <ListView.Header>
        <Grid>
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="2*"/>
                <ColumnDefinition Width="*"/>
                <ColumnDefinition Width="*"/>
                <ColumnDefinition Width="*"/>
            </Grid.ColumnDefinitions>
            <TextBlock Grid.Column="0" Text="Nome" FontWeight="Bold"/>
            <TextBlock Grid.Column="1" Text="Tipo" FontWeight="Bold"/>
            <TextBlock Grid.Column="2" Text="Tamanho" FontWeight="Bold"/>
            <TextBlock Grid.Column="3" Text="Data" FontWeight="Bold"/>
        </Grid>
    </ListView.Header>
    <ListView.ItemTemplate>
        <DataTemplate x:DataType="local:FileItem">
            <Grid>
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="2*"/>
                    <ColumnDefinition Width="*"/>
                    <ColumnDefinition Width="*"/>
                    <ColumnDefinition Width="*"/>
                </Grid.ColumnDefinitions>
                <TextBlock Grid.Column="0" Text="{x:Bind Name}"/>
                <TextBlock Grid.Column="1" Text="{x:Bind Type}"/>
                <TextBlock Grid.Column="2" Text="{x:Bind Size, StringFormat={}{0} KB}"/>
                <TextBlock Grid.Column="3" Text="{x:Bind DateModified, StringFormat={}{0:dd/MM/yyyy}}"/>
            </Grid>
        </DataTemplate>
    </ListView.ItemTemplate>
</ListView>
```

**Explicação:**
- **Header:** Define os títulos das colunas usando um `Grid` com as definições de colunas apropriadas.
- **ItemTemplate:** Cada item da lista é organizado em um `Grid` que alinha os dados nas colunas correspondentes.

### 2. **DataGrid do Windows Community Toolkit**

Se você precisa de uma funcionalidade de grid mais robusta, como ordenação, agrupamento, edição inline, etc., o `DataGrid` do [Windows Community Toolkit](https://github.com/CommunityToolkit/WindowsCommunityToolkit) pode ser uma ótima opção.

**Passos para usar o DataGrid:**

1. **Adicionar a Referência do Toolkit:**
   - Adicione o pacote NuGet `Microsoft.Toolkit.WinUI.UI.Controls` ao seu projeto.

2. **Usar o DataGrid no XAML:**

```xml
<Window
    x:Class="YourApp.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:controls="using:Microsoft.Toolkit.Uwp.UI.Controls"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:local="using:YourApp"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">
    
    <Grid>
        <controls:DataGrid ItemsSource="{x:Bind Files}" AutoGenerateColumns="False">
            <controls:DataGrid.Columns>
                <controls:DataGridTextColumn Header="Nome" Binding="{Binding Name}" />
                <controls:DataGridTextColumn Header="Tipo" Binding="{Binding Type}" />
                <controls:DataGridTextColumn Header="Tamanho" Binding="{Binding Size, StringFormat={}{0} KB}" />
                <controls:DataGridTextColumn Header="Data" Binding="{Binding DateModified, StringFormat={}{0:dd/MM/yyyy}}" />
            </controls:DataGrid.Columns>
        </controls:DataGrid>
    </Grid>
</Window>
```

**Vantagens:**
- **Funcionalidades Avançadas:** Suporte para ordenação, agrupamento, edição e mais.
- **Personalização:** Fácil de personalizar e estender conforme necessidade.

### 3. **GridView para Layout em Grade**

Se a intenção é mais de apresentar os arquivos de forma visualmente em grade (como miniaturas) e não necessariamente com colunas de dados, o `GridView` pode ser apropriado. No entanto, para exibição estruturada com múltiplas colunas de dados, o `ListView` ou `DataGrid` são mais indicados.

### Considerações Finais

- **Escolha do Controle:** Para listas simples com múltiplas colunas, `ListView` com `Grid` no `DataTemplate` geralmente é suficiente. Se precisar de funcionalidades avançadas de grid, considere usar o `DataGrid` do Windows Community Toolkit.
- **Performance:** Avalie a quantidade de dados e a complexidade do layout para garantir uma boa performance da UI.
- **Estilo e Temas:** Aproveite os recursos de temas do WinUI 3 para manter a consistência visual da aplicação.

**Referências Úteis:**
- [Documentação do ListView no WinUI 3](https://learn.microsoft.com/pt-br/windows/apps/winui/winui3/)
- [Windows Community Toolkit - DataGrid](https://learn.microsoft.com/pt-br/windows/communitytoolkit/controls/datagrid)

Espero que isso ajude a escolher o melhor controle para sua aplicação!

ترجم للانجليزي:
عملية قلب مفتوح
لقد أنشأنا نظامًا طبيًا وفنيًا يمكننا من تحقيق النجاح في إجراء عمليات القلب الرئيسية.
جراحات نادرة ومتخصصة
يقدم فريقنا الطبي مجموعة من الخدمات الجراحية النادرة التي نسعى من خلالها إلى علاج الأمراض النادرة دون الحاجة للسفر خارج الدولة.
الولادة تحت الماء
لقد قدمنا طرقًا جديدة للولادة تساعد النساء الحوامل على إكمال عملية ولادة أطفالهن بألم أقل.
جراحة قاعدة الجمجمة بالمنظار
جهزنا مستشفانا بأحدث الأجهزة من أفضل الأصول العالمية والتي يتم إدخالها واستخدامها لأول مرة في بلادنا.

جراحة العمود الفقري والكسور
نقدم أحدث الخدمات في مجال الوقاية والتشخيص وكذلك الجراحة والعلاج وإعادة التأهيل فيما يتعلق بجميع أمراض العظام والمفاصل والعمود الفقري.
جراحة المناظير
نستخدم التقنيات الحديثة التي تلغي الحاجة إلى التدخل الجراحي في إجراء بعض العمليات ، حيث نقدم أجهزة عالية الدقة بأبعاد حقيقية تمكن الاختصاصي من الوصول إلى المنطقة المراد علاجها بسهولة.
العناية المركزة بالطفل
على أيدي أطبائنا ، سوف يزدهر قلبك بزهور الربيع ، والعمليات الكبرى ، والمخاطر العالية ، لكن نجاحهم مضمون في مستشفانا ، ويسعدنا أن نكون جزءًا من رحلة الشفاء.



إسعاف الطوارئ
على أيدي أطبائنا ، سوف يزدهر قلبك بزهور الربيع ، والعمليات الكبرى ، والمخاطر العالية ، لكن نجاحهم مضمون في مستشفانا ، ويسعدنا أن نكون جزءًا من رحلة الشفاء.
خدمات الأشعة والتصوير بالرنين المغناطيسي والتصوير بالرنين المغناطيسي والتحليلات المتخصصة
على أيدي أطبائنا ، سوف يزدهر قلبك بزهور الربيع ، والعمليات الكبرى ، والمخاطر العالية ، لكن نجاحهم مضمون في مستشفانا ، ويسعدنا أن نكون جزءًا من رحلة الشفاء.

**Open Heart Surgery**

We have established a medical and technical system that enables us to achieve success in performing major heart surgeries.

**Rare and Specialized Surgeries**

Our medical team offers a range of rare surgical services through which we strive to treat rare diseases without the need to travel outside the country.

**Water Birth**

We have introduced new birthing methods that help pregnant women complete the childbirth process with less pain.

**Endoscopic Skull Base Surgery**

We have equipped our hospital with the latest devices from the best global sources that are being introduced and used for the first time in our country.

**Spine and Fracture Surgery**

We offer the latest services in prevention, diagnosis, as well as surgery, treatment, and rehabilitation regarding all bone, joint, and spine diseases.

**Endoscopic Surgery**

We use modern techniques that eliminate the need for surgical intervention in performing certain procedures, as we provide high-precision devices with real dimensions that enable the specialist to access the area to be treated easily.

**Intensive Care for Children**

Under the hands of our doctors, your heart will flourish with spring flowers, major operations, and high risks, but their success is guaranteed in our hospital, and we are pleased to be part of the healing journey.

**Emergency Ambulance**

Under the hands of our doctors, your heart will flourish with spring flowers, major operations, and high risks, but their success is guaranteed in our hospital, and we are pleased to be part of the healing journey.

**Radiology Services, Magnetic Resonance Imaging, and Specialized Analyses**

Under the hands of our doctors, your heart will flourish with spring flowers, major operations, and high risks, but their success is guaranteed in our hospital, and we are pleased to be part of the healing journey.

سوف ارسل لك كود واريد منك ان تشرح لي تفاصيل الكود 

بالطبع، أنا هنا لمساعدتك! من فضلك قم بإرسال الكود الذي تود شرح تفاصيله وسأقوم بشرحه لك بالتفصيل.

سلام
                            
                            

سلام! چطور می‌تونم کمکتون کنم؟

یه مقاله در مورد درونگرایی با رنفرنس معتبر بنویس
                            
                            

درونگرایی یکی از ویژگی‌های شخصیتی است که توسط روانشناس کارل یونگ معرفی شد. این ویژگی به افرادی اشاره دارد که تمایل دارند انرژی خود را بیشتر از درون و از تفکرات و احساسات شخصی‌شان بگیرند، برخلاف برونگراها که انرژی خود را بیشتر از تعاملات اجتماعی می‌گیرند. در ادامه به بررسی ویژگی‌ها و تأثیرات درونگرایی می‌پردازیم.

### ویژگی‌های درونگرایان
1. **تمرکز بر دنیای درونی:** درونگراها معمولاً بیشتر به دنیای درونی خود و تفکرات و ایده‌های شخصی توجه می‌کنند.
2. **تفکر عمیق:** این افراد تمایل دارند پیش از اقدام به تفکر بپردازند و بیشتر بر تحلیل و بررسی مسائل متمرکز شوند.
3. **ارتباطات محدودتر:** درونگراها معمولاً تعداد محدودی از دوستان نزدیک دارند و از تعاملات اجتماعی گسترده پرهیز می‌کنند.
4. **گوش دادن به جای صحبت کردن:** آن‌ها معمولاً شنوندگان خوبی هستند و به جای صحبت زیاد، بیشتر گوش می‌دهند.

### تأثیرات درونگرایی
1. **توانایی‌های تحلیلی قوی:** درونگراها به دلیل تمرکز بالا و تفکر عمیق، معمولاً توانایی‌های تحلیلی قوی‌تری دارند.
2. **خلاقیت بالا:** توجه به دنیای درونی و پرداختن به جزئیات می‌تواند منجر به خلاقیت بیشتر در این افراد شود.
3. **نیاز به تنهایی:** درونگراها به فضای شخصی و زمانی برای خود نیاز دارند تا انرژی خود را بازیابی کنند.
4. **مدیریت استرس:** این افراد ممکن است در موقعیت‌های اجتماعی پرتلاش، استرس بیشتری را تجربه کنند.

### رفرنس معتبر
برای مطالعه بیشتر و دریافت اطلاعات دقیق و علمی در مورد درونگرایی می‌توانید به کتاب "شخصیت‌های ساکت" (Quiet: The Power of Introverts in a World That Can't Stop Talking) نوشته سوزان کین مراجعه کنید. همچنین مقالات علمی منتشر شده در مجلات روانشناسی مانند "Journal of Personality" و "Personality and Individual Differences" منابع معتبری برای اطلاعات بیشتر محسوب می‌شوند.

در نهایت، مهم است به یاد داشته باشیم که درونگرایی و برونگرایی یک طیف است و افراد می‌توانند ویژگی‌هایی از هر دو نوع را داشته باشند. شناخت این ویژگی‌ها می‌تواند به بهبود روابط اجتماعی و درک بهتر خود و دیگران کمک کند.