Foundry Testing – Differences in Pranking Between Test Contracts

You should note that if you call createB like previously:

function createB(string name) public returns (address) {
  return new B(name)
}

Inside B constructor you will have msg.sender = address(A), because A is creating B.

To make it work as intended you have to send the owner to B constructor like this:

Contract A.sol

pragma solidity ^0.4.13;

import "./B.sol";

contract A {
    address public owner;
    function A() {
        owner = msg.sender;
    }

    function createB(string name) public returns (address) {
        return new B(owner, name);
    }
}

Contract B.sol

pragma solidity ^0.4.13;

contract B {
    address public owner;
    string public name;
    function B(address _owner, string _name) {
        owner = _owner;
        name = _name;
    }
}

Contract TestB.sol

pragma solidity ^0.4.13;

import "truffle/Assert.sol";
import "truffle/DeployedAddresses.sol";
import "../contracts/A.sol";
import "../contracts/B.sol";

contract TestB {
  B testB;
  A testA;

  function beforeEach() {
    testA = A(DeployedAddresses.A());
    testB = B(testA.createB("test"));
  }

  function testIsOwnerIsSet() {
    address aOwner = testA.owner();
    address bOwner = testB.owner();
    Assert.equal(aOwner, bOwner, "Owner's address does not match");
  }
}

---

Before Edit

But you never call owner you are comparing the addresses of contract A, and contract B. You should compare

Assert.equal(address(A), address(B.owner), "Owner's address does not match") 

But make sure owner is public in contract B.

When you want to withdraw and the signing account is the deployer and test contract itself (it's the same), like you have, then you need to give the contract TestContract is Test the ability to receive ether, like you would do for any other contract. Add the following to the contracts body.

// Function to receive Ether. msg.data must be empty
receive() external payable {}

// Fallback function is called when msg.data is not empty
fallback() external payable {}

Other than that you could use vm.prank and specify an EOA which is capable of receiving ether anyway. Remember you would need to use vm.prank for contract deployment (owner is not test contract but EOA and before withdraw function execution)