diff --git a/gtsam/linear/tests/testVectorValuesUnordered.cpp b/gtsam/linear/tests/testVectorValuesUnordered.cpp
index a2054f4f0..dd988217c 100644
--- a/gtsam/linear/tests/testVectorValuesUnordered.cpp
+++ b/gtsam/linear/tests/testVectorValuesUnordered.cpp
@@ -27,7 +27,9 @@ using namespace boost::assign;
 using namespace gtsam;
 
 /* ************************************************************************* */
-TEST(VectorValues, insert) {
+TEST(VectorValuesUnordered, basics)
+{
+  // Tests insert(), size(), dim(), exists(), vector()
 
   // insert
   VectorValuesUnordered actual;
@@ -37,7 +39,7 @@ TEST(VectorValues, insert) {
   actual.insert(2, Vector_(2, 4.0, 5.0));
 
   // Check dimensions
-  LONGS_EQUAL(6, actual.size());
+  LONGS_EQUAL(4, actual.size());
   LONGS_EQUAL(1, actual.dim(0));
   LONGS_EQUAL(2, actual.dim(1));
   LONGS_EQUAL(2, actual.dim(2));
@@ -57,7 +59,7 @@ TEST(VectorValues, insert) {
   EXPECT(assert_equal(Vector_(2, 2.0, 3.0), actual[1]));
   EXPECT(assert_equal(Vector_(2, 4.0, 5.0), actual[2]));
   EXPECT(assert_equal(Vector_(2, 6.0, 7.0), actual[5]));
-  EXPECT(assert_equal(Vector_(7, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0), actual.asVector()));
+  EXPECT(assert_equal(Vector_(7, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0), actual.vector()));
 
   // Check exceptions
   CHECK_EXCEPTION(actual.insert(1, Vector()), invalid_argument);
@@ -65,7 +67,8 @@ TEST(VectorValues, insert) {
 }
 
 /* ************************************************************************* */
-TEST(VectorValues, combine) {
+TEST(VectorValuesUnordered, combine)
+{
   VectorValuesUnordered expected;
   expected.insert(0, Vector_(1, 1.0));
   expected.insert(1, Vector_(2, 2.0, 3.0));
@@ -86,19 +89,73 @@ TEST(VectorValues, combine) {
 }
 
 /* ************************************************************************* */
-TEST(VectorValues, subvector) {
+TEST(VectorValuesUnordered, subvector)
+{
   VectorValuesUnordered init;
-  init.insert(0, Vector_(1, 1.0));
-  init.insert(1, Vector_(2, 2.0, 3.0));
-  init.insert(2, Vector_(2, 4.0, 5.0));
-  init.insert(3, Vector_(2, 6.0, 7.0));
+  init.insert(10, Vector_(1, 1.0));
+  init.insert(11, Vector_(2, 2.0, 3.0));
+  init.insert(12, Vector_(2, 4.0, 5.0));
+  init.insert(13, Vector_(2, 6.0, 7.0));
 
   std::vector<Key> keys;
-  keys += 0, 2, 3;
+  keys += 10, 12, 13;
   Vector expSubVector = Vector_(5, 1.0, 4.0, 5.0, 6.0, 7.0);
   EXPECT(assert_equal(expSubVector, init.vector(keys)));
 }
 
+/* ************************************************************************* */
+TEST(VectorValuesUnordered, LinearAlgebra)
+{
+  VectorValuesUnordered test1;
+  test1.insert(0, Vector_(1, 1.0));
+  test1.insert(1, Vector_(2, 2.0, 3.0));
+  test1.insert(5, Vector_(2, 6.0, 7.0));
+  test1.insert(2, Vector_(2, 4.0, 5.0));
+
+  VectorValuesUnordered test2;
+  test2.insert(0, Vector_(1, 6.0));
+  test2.insert(1, Vector_(2, 1.0, 6.0));
+  test2.insert(5, Vector_(2, 4.0, 3.0));
+  test2.insert(2, Vector_(2, 1.0, 8.0));
+
+  // Dot product
+  double dotExpected = test1.vector().dot(test2.vector());
+  double dotActual = test1.dot(test2);
+  DOUBLES_EQUAL(dotExpected, dotActual, 1e-10);
+
+  // Norm
+  double normExpected = test1.vector().norm();
+  double normActual = test1.norm();
+  DOUBLES_EQUAL(normExpected, normActual, 1e-10);
+
+  // Squared norm
+  double sqNormExpected = test1.vector().norm();
+  double sqNormActual = test1.norm();
+  DOUBLES_EQUAL(sqNormExpected, sqNormActual, 1e-10);
+
+  // Addition
+  Vector sumExpected = test1.vector() + test2.vector();
+  VectorValuesUnordered sumActual = test1 + test2;
+  EXPECT(sumActual.hasSameStructure(test1));
+  EXPECT(assert_equal(sumExpected, sumActual.vector()));
+  Vector sum2Expected = sumActual.vector() + test1.vector();
+  VectorValuesUnordered sum2Actual = sumActual;
+  sum2Actual += test1;
+  EXPECT(assert_equal(sum2Expected, sum2Actual.vector()));
+
+  // Subtraction
+  Vector difExpected = test1.vector() - test2.vector();
+  VectorValuesUnordered difActual = test1 - test2;
+  EXPECT(difActual.hasSameStructure(test1));
+  EXPECT(assert_equal(difExpected, difActual.vector()));
+
+  // Scaling
+  Vector scalExpected = test1.vector() * 5.0;
+  VectorValuesUnordered scalActual = test1;
+  scalActual *= 5.0;
+  EXPECT(assert_equal(scalExpected, scalActual.vector()));
+}
+
 /* ************************************************************************* */
 int main() { TestResult tr; return TestRegistry::runAllTests(tr); }
 /* ************************************************************************* */