text: Q:
  
  C++ testing for compile errors
  
  I'm a student, and I'm trying to write and run some test code for an assignment to check it before I turn it in. What I'm trying to do now is test that my code prevents value semantics properly. In my assignment, I have declared for each of my classes its own private copy constructor and assignment operator that have no definition, and so do nothing. When they are called in my test program, I am getting compile errors like I expected. Something like this:
  
  error: 'myClass::myClass(const &myClass)' is private'
  error: 'myClass& myClass::operator=(const myClass&)' is private
  
  Is there a way to use try/catch so that my test code will compile and run, but show me that these errors did occur?
  I've tried:
  myClass obj1(...);
  myClass obj2(...);
  try{
    obj1 = obj2;
    throw 1;
  }
  catch(int e){
    assert(e==1);
  }
  
  but the compiler is still giving me the above errors. Are these not 'exceptions'? Will they not trigger a throw?
  If I'm understanding try/catch correctly, it handles runtime errors, not the kind errors I was getting above, correct?
  After doing some more research, it seems that there is no (easy) way of testing for certain compile errors natively within C++ (this maybe true for most languages, now that I think about it). I read a post that suggests writing some test code in a scripting language that attempts to compile snippets of C++ code and checks for any errors, and another post that recommends using Boost.Build.
  What is the easiest/best way of doing what I'm trying to do?
  I looked at the documentation for Boost.Build and it's a bit over my head. If I used it, how would I test that a file, say 'test.cpp' compiles, and maybe handle specific compile errors that occur with 'test.cpp'?
  Thanks for your help!
  P.S. This is one of my first posts, hopefully I've done "enough" research, and done everything else properly. Sorry if I didn't.
  
  A:
  
  try-catch happens at runtime, whereas the compiler statically tries to link functions you are calling at compile time, so compilation will always fail.
  Alternatively, If you are willing to use C++ exceptions, then you could just implement the copy and assignment methods, make them public, and just throw an exception in the body of those functions. Note that in basically every situation, you should prefer static/compile-time checks over runtime checks if you have a choice.
  
  A:
  
  These are compiler errors, not exceptions. Exceptions are a mechanism for programmers to throw run-time errors and catch/handle them. The compiler fails to even build an executable for you to run because it recognizes that the code is malformed and is invalid C++ code.
  If you want to make this a run-time error, make the method public/use friends/whatever you need to do to provide access to something and throw an exception in the method's definition, the catch and handle the exception in the calling code.
  I don't see a purpose in doing this however. Always prefer a compile-time error to a run-time error. Always.
  The C++ standard defines what is valid or invalid code, with some things left as undefined and other things left up to whoever implements the compiler. Any standard compliant C++ compiler will give an error because something does not meet the standard/definition and is thus invalid. The errors are generally to say that something is ambiguous or straight up nonsensical and you need to revise what you've written.
  Run-time errors are either crashes or behavior that is unintended and unwanted from the perspective of the user. Compiler errors are the compiler saying "I don't understand what you're saying. This doesn't make sense.". Compiler warnings are the compiler saying "I'll let you do this, but I probably shouldn't. Are you really sure this is what you meant?".
  
  A:
  
  What you really want to test is not the compiler failing, but you want to test certain assumptions about your class.
  In your test file, put #include <type_traits>
  and then add
  assert((std::is_assignable <myClass, myClass> ::value) == FALSE);
  assert((std::is_copy_assignable<myClass> ::value) == FALSE);
  assert((std::is_copy_constructible<myClass> ::value) == FALSE);
  
  The various traits you can check for are documented here:
  http://en.cppreference.com/w/cpp/types
  Notice, you'll have to compile for C++11 to use most of these functions.
  (as described first in Assert that code does NOT compile)
  
  