Q:

Iterator for a list of objects

Given a list of objects, return an iterator for such a list. Looking for code-review, optimizations and best practices. Verifying complexity to be O(n) where n is sum of all objects, including elements of collections if contained. previously solved here.
public class FlattenIterator implements Iterator<Object> {

    private final Stack<Iterator<?>> iteratorStack;
    private Object next;

    public FlattenIterator(Iterable<?> list) {
        if (list == null) {
            throw new NullPointerException();
        }

        iteratorStack = new Stack<Iterator<?>>();
        iteratorStack.push(list.iterator());
    }

    private void moveToNext() {
       while ((next == null) && !iteratorStack.empty()) {
            Iterator<?> itr = iteratorStack.peek();

            // if iterator is empty, then pop it from stack.
            if (!itr.hasNext()) {
                iteratorStack.pop();
            } else {
                final Object next = itr.next();
                if (next instanceof Iterable) {
                    iteratorStack.push(((Iterable<?>) next).iterator());
                    moveToNext();
                } else {
                    this.next = next;
                }
            }
        }
    }

    /**
     * Returns if there are any objects left to iterate over. This method 
     * can change the internal state of the object when it is called, but repeated
     * calls to it will not have any additional side effects.
     */
    public boolean hasNext() {
        moveToNext();
        return next != null;
    }

    /**
     * Returns the next element in our iteration, throwing a NoSuchElementException
     * if none is found. 
     */
    public Object next() {
        moveToNext();
        if (next == null) {
            throw new NoSuchElementException(); 
        }

        Object objectToReturn = next;
        next = null;
        return objectToReturn;
    }

    public void remove() {
        throw new UnsupportedOperationException();
    }
}

public class FlattenIteratorTest {

    @Test
    public void testIterator() {
        /**
         *  < <1, 2>, <"abc", "xyz">  <<1, 2>, <"abc", "xyz">> , a, 10 >
         */
        List<Object> genericList = new ArrayList<Object>();

        // integer list
        List<Integer> listInteger = new ArrayList<Integer>(Arrays.asList(1, 2));

        // string list
        List<String> listString = new ArrayList<String>(Arrays.asList("abc", "xyz"));

        // nested lists.
        List<Object> nestedList = new ArrayList<Object>();
        nestedList.add(listInteger);
        nestedList.add(listString);

        genericList.add(listInteger);
        genericList.add(listString);
        genericList.add(nestedList);
        genericList.add('a');
        genericList.add(10);

        /**
         * A very simple test case.
         */
        FlattenIterator fi = new FlattenIterator(genericList); 
        final List<Object> listExpected = new ArrayList<>(Arrays.asList(1, 2, "abc", "xyz", 1, 2, "abc", "xyz", 'a', 10));
        final List<Object> listActual = new ArrayList<>();
        while (fi.hasNext()) {
           listActual.add(fi.next());
        }    
        assertTrue(listExpected.equals(listActual));
    }

    @Test
    public void testEmpty() {
        List<Integer> list = new ArrayList<>();
        list.addAll(list);
        FlattenIterator fi = new FlattenIterator(list);
        assertFalse(fi.hasNext());
    }

}

A:

I'm going to hit the high notes on my phone and swing back later with details unless someone beats me to it. 
Allow null
Add a separate boolean field to track when next holds the actual next element rather than using null as a signal that it needs to be populated so that null elements can be supported.
Avoid Recursion
In this case, there's no reason for moveToNext to call itself. Continuing the loop should have the same effect. 
Use Generics
Even though you're stuck using Object for variables which may hold an element or an iterable, you can still add a generic type T to the class and specify it as the return type from next. At least, I think you can. :) 
Testing
When using the @Test annotation, you don't have to prefix each test method name with test. However, you really need more descriptive method names, and each test should validate one specific condition. 
Burn this into your brain: Arrange, Act, Assert. Arrange the test fixture in the initial state, perform the action being tested, and assert the results. It can become tedious to setup the fixture each time, but helper methods can ease the pain and promote DRYness. 

A:

You have the general right idea, I think.
Naming
FlattenIterator is slightly off, since it is a Verb+Noun.  I suggest FlatteningIterator, which is an Adjective+Noun.
Generics
I agree with @DavidHarkness.  Even if the Iterables you pass in are non-homogeneous, your class should still be some kind of Iterator<T> rather than just an Iterator.
moveToNext()
Of course, this is where the main challenge is.
The fact that hasNext() calls moveToNext() is weird, since hasNext() should have no visible side-effects.  Therefore, either it's wrong for hasNext() to call moveToNext(), or moveToNext() is lying and doesn't always advance.  In fact, the latter is true: moveToNext() is "disabled" unless next is null, which happens either when the FlattenIterator is freshly constructed or after you clear next at the end of next().  So, just call moveToNext() at the end of the constructor and at the end of next(), but not in hasNext().  Problem solved — no more lying.
As @DavidHarkness points out, encountering a null value among the iterables causes premature termination.  You don't want to test whether next is null.  Rather, I propose that you test whether the iteratorStack is empty to know when to terminate.
public class FlatteningIterator<T> implements Iterator<T> {

    private final Stack<Iterator<?>> iteratorStack;
    private T next;

    public FlatteningIterator(Iterable<?> list) {
        if (list == null) {
            throw new NullPointerException();
        }

        iteratorStack = new Stack<Iterator<?>>();
        iteratorStack.push(list.iterator());
        moveToNext();
    }

    @SuppressWarnings("unchecked")    // Needed for this.next = (T)next
    private void moveToNext() {
       this.next = null;              // Avoid lingering memory reference
       do {
            Iterator<?> itr = iteratorStack.peek();

            // if iterator is empty, then pop it from stack.
            if (!itr.hasNext()) {
                iteratorStack.pop();
            } else {
                final Object next = itr.next();
                if (next instanceof Iterable) {
                    iteratorStack.push(((Iterable<?>)next).iterator());
                } else {
                    this.next = (T)next;
                    break;
                }
            }
        } while (!this.iteratorStack.isEmpty());
    }

    /**
     * Returns if there are any objects left to iterate over.
     */
    public boolean hasNext() {
        return !this.iteratorStack.isEmpty();
    }

    /**
     * Returns the next element in our iteration, throwing a NoSuchElementException
     * if none is found. 
     */
    public T next() {
        if (this.iteratorStack.isEmpty()) {
            throw new NoSuchElementException();
        }
        try {
            return this.next;
        } finally {
            moveToNext();
        }
    }

    public void remove() {
        throw new UnsupportedOperationException();
    }
}

