Rename enumerations to comply with Qt style

Change-Id: Id72fe27cec606e7f02b8e9ac1d0d763890e86a95
Reviewed-by: Kurt Pattyn <pattyn.kurt@gmail.com>

4 files changed, 327 insertions, 283 deletions

diff --git a/tests/auto/dataprocessor/tst_dataprocessor.cpp b/tests/auto/dataprocessor/tst_dataprocessor.cpp
index f99a569..4fc3a6e 100644
--- a/tests/auto/dataprocessor/tst_dataprocessor.cpp
+++ b/tests/auto/dataprocessor/tst_dataprocessor.cpp
@@ -249,7 +249,7 @@ void tst_DataProcessor::goodBinaryFrame()
     QWebSocketDataProcessor dataProcessor;
     QFETCH(QByteArray, payload);
 
-    data.append((char)(FIN | QWebSocketProtocol::OC_BINARY));
+    data.append((char)(FIN | QWebSocketProtocol::OpCodeBinary));
 
     if (payload.length() < 126)
     {
@@ -331,7 +331,7 @@ void tst_DataProcessor::goodTextFrame()
     QFETCH(QByteArray, payload);
     QFETCH(int, size);
 
-    data.append((char)(FIN | QWebSocketProtocol::OC_TEXT));
+    data.append((char)(FIN | QWebSocketProtocol::OpCodeText));
 
     if (payload.length() < 126)
     {
@@ -395,7 +395,7 @@ void tst_DataProcessor::goodControlFrame()
     QSignalSpy pingReceivedSpy(&dataProcessor, SIGNAL(pingReceived(QByteArray)));
     QSignalSpy pongReceivedSpy(&dataProcessor, SIGNAL(pongReceived(QByteArray)));
 
-    data.append((char)(FIN | QWebSocketProtocol::OC_PING));
+    data.append((char)(FIN | QWebSocketProtocol::OpCodePing));
     data.append(QChar::fromLatin1(0));
     buffer.setData(data);
     buffer.open(QIODevice::ReadOnly);
@@ -413,7 +413,7 @@ void tst_DataProcessor::goodControlFrame()
     data.clear();
     pingReceivedSpy.clear();
     pongReceivedSpy.clear();
-    data.append((char)(FIN | QWebSocketProtocol::OC_PONG));
+    data.append((char)(FIN | QWebSocketProtocol::OpCodePong));
     data.append(QChar::fromLatin1(0));
     buffer.setData(data);
     buffer.open(QIODevice::ReadOnly);
@@ -437,55 +437,82 @@ void tst_DataProcessor::goodCloseFrame_data()
     for (int i = 0; i < 124; ++i)
     {
         QTest::newRow(QStringLiteral("Close frame with %1 ASCII characters").arg(i).toLatin1().constData())
-                << QString(i, 'a') << QWebSocketProtocol::CC_NORMAL;
+                << QString(i, 'a') << QWebSocketProtocol::CloseCodeNormal;
     }
     for (int i = 0; i < 126; ++i)
     {
         QTest::newRow(QStringLiteral("Text frame with containing ASCII character '0x%1'")
                       .arg(QByteArray(1, char(i)).toHex().constData()).toLatin1().constData())
-                << QString(1, char(i)) << QWebSocketProtocol::CC_NORMAL;
+                << QString(1, char(i)) << QWebSocketProtocol::CloseCodeNormal;
     }
-    QTest::newRow("Close frame with close code NORMAL") << QString(1, 'a') << QWebSocketProtocol::CC_NORMAL;
-    QTest::newRow("Close frame with close code BAD OPERATION") << QString(1, 'a') << QWebSocketProtocol::CC_BAD_OPERATION;
-    QTest::newRow("Close frame with close code DATATYPE NOT SUPPORTED") << QString(1, 'a') << QWebSocketProtocol::CC_DATATYPE_NOT_SUPPORTED;
-    QTest::newRow("Close frame with close code GOING AWAY") << QString(1, 'a') << QWebSocketProtocol::CC_GOING_AWAY;
-    QTest::newRow("Close frame with close code MISSING EXTENSION") << QString(1, 'a') << QWebSocketProtocol::CC_MISSING_EXTENSION;
-    QTest::newRow("Close frame with close code POLICY VIOLATED") << QString(1, 'a') << QWebSocketProtocol::CC_POLICY_VIOLATED;
-    QTest::newRow("Close frame with close code PROTOCOL ERROR") << QString(1, 'a') << QWebSocketProtocol::CC_PROTOCOL_ERROR;
-    QTest::newRow("Close frame with close code TOO MUCH DATA") << QString(1, 'a') << QWebSocketProtocol::CC_TOO_MUCH_DATA;
-    QTest::newRow("Close frame with close code WRONG DATATYPE") << QString(1, 'a') << QWebSocketProtocol::CC_WRONG_DATATYPE;
-    QTest::newRow("Close frame with close code 3000") << QString(1, 'a') << QWebSocketProtocol::CloseCode(3000);
-    QTest::newRow("Close frame with close code 3999") << QString(1, 'a') << QWebSocketProtocol::CloseCode(3999);
-    QTest::newRow("Close frame with close code 4000") << QString(1, 'a') << QWebSocketProtocol::CloseCode(4000);
-    QTest::newRow("Close frame with close code 4999") << QString(1, 'a') << QWebSocketProtocol::CloseCode(4999);
+    QTest::newRow("Close frame with close code NORMAL")
+            << QString(1, 'a') << QWebSocketProtocol::CloseCodeNormal;
+    QTest::newRow("Close frame with close code BAD OPERATION")
+            << QString(1, 'a') << QWebSocketProtocol::CloseCodeBadOperation;
+    QTest::newRow("Close frame with close code DATATYPE NOT SUPPORTED")
+            << QString(1, 'a') << QWebSocketProtocol::CloseCodeDatatypeNotSupported;
+    QTest::newRow("Close frame with close code GOING AWAY")
+            << QString(1, 'a') << QWebSocketProtocol::CloseCodeGoingAway;
+    QTest::newRow("Close frame with close code MISSING EXTENSION")
+            << QString(1, 'a') << QWebSocketProtocol::CloseCodeMissingExtension;
+    QTest::newRow("Close frame with close code POLICY VIOLATED")
+            << QString(1, 'a') << QWebSocketProtocol::CloseCodePolicyViolated;
+    QTest::newRow("Close frame with close code PROTOCOL ERROR")
+            << QString(1, 'a') << QWebSocketProtocol::CloseCodeProtocolError;
+    QTest::newRow("Close frame with close code TOO MUCH DATA")
+            << QString(1, 'a') << QWebSocketProtocol::CloseCodeTooMuchData;
+    QTest::newRow("Close frame with close code WRONG DATATYPE")
+            << QString(1, 'a') << QWebSocketProtocol::CloseCodeWrongDatatype;
+    QTest::newRow("Close frame with close code 3000")
+            << QString(1, 'a') << QWebSocketProtocol::CloseCode(3000);
+    QTest::newRow("Close frame with close code 3999")
+            << QString(1, 'a') << QWebSocketProtocol::CloseCode(3999);
+    QTest::newRow("Close frame with close code 4000")
+            << QString(1, 'a') << QWebSocketProtocol::CloseCode(4000);
+    QTest::newRow("Close frame with close code 4999")
+            << QString(1, 'a') << QWebSocketProtocol::CloseCode(4999);
 
     //close frames with no close reason
-    QTest::newRow("Close frame with close code NORMAL and no reason") << QString() << QWebSocketProtocol::CC_NORMAL;
-    QTest::newRow("Close frame with close code BAD OPERATION and no reason") << QString() << QWebSocketProtocol::CC_BAD_OPERATION;
-    QTest::newRow("Close frame with close code DATATYPE NOT SUPPORTED and no reason") << QString() << QWebSocketProtocol::CC_DATATYPE_NOT_SUPPORTED;
-    QTest::newRow("Close frame with close code GOING AWAY and no reason") << QString() << QWebSocketProtocol::CC_GOING_AWAY;
-    QTest::newRow("Close frame with close code MISSING EXTENSION and no reason") << QString() << QWebSocketProtocol::CC_MISSING_EXTENSION;
-    QTest::newRow("Close frame with close code POLICY VIOLATED and no reason") << QString() << QWebSocketProtocol::CC_POLICY_VIOLATED;
-    QTest::newRow("Close frame with close code PROTOCOL ERROR and no reason") << QString() << QWebSocketProtocol::CC_PROTOCOL_ERROR;
-    QTest::newRow("Close frame with close code TOO MUCH DATA and no reason") << QString() << QWebSocketProtocol::CC_TOO_MUCH_DATA;
-    QTest::newRow("Close frame with close code WRONG DATATYPE and no reason") << QString() << QWebSocketProtocol::CC_WRONG_DATATYPE;
-    QTest::newRow("Close frame with close code 3000 and no reason") << QString() << QWebSocketProtocol::CloseCode(3000);
-    QTest::newRow("Close frame with close code 3999 and no reason") << QString() << QWebSocketProtocol::CloseCode(3999);
-    QTest::newRow("Close frame with close code 4000 and no reason") << QString() << QWebSocketProtocol::CloseCode(4000);
-    QTest::newRow("Close frame with close code 4999 and no reason") << QString() << QWebSocketProtocol::CloseCode(4999);
-
-    QTest::newRow("Close frame with no close code and no reason") << QString() << QWebSocketProtocol::CloseCode(0);
+    QTest::newRow("Close frame with close code NORMAL and no reason")
+            << QString() << QWebSocketProtocol::CloseCodeNormal;
+    QTest::newRow("Close frame with close code BAD OPERATION and no reason")
+            << QString() << QWebSocketProtocol::CloseCodeBadOperation;
+    QTest::newRow("Close frame with close code DATATYPE NOT SUPPORTED and no reason")
+            << QString() << QWebSocketProtocol::CloseCodeDatatypeNotSupported;
+    QTest::newRow("Close frame with close code GOING AWAY and no reason")
+            << QString() << QWebSocketProtocol::CloseCodeGoingAway;
+    QTest::newRow("Close frame with close code MISSING EXTENSION and no reason")
+            << QString() << QWebSocketProtocol::CloseCodeMissingExtension;
+    QTest::newRow("Close frame with close code POLICY VIOLATED and no reason")
+            << QString() << QWebSocketProtocol::CloseCodePolicyViolated;
+    QTest::newRow("Close frame with close code PROTOCOL ERROR and no reason")
+            << QString() << QWebSocketProtocol::CloseCodeProtocolError;
+    QTest::newRow("Close frame with close code TOO MUCH DATA and no reason")
+            << QString() << QWebSocketProtocol::CloseCodeTooMuchData;
+    QTest::newRow("Close frame with close code WRONG DATATYPE and no reason")
+            << QString() << QWebSocketProtocol::CloseCodeWrongDatatype;
+    QTest::newRow("Close frame with close code 3000 and no reason")
+            << QString() << QWebSocketProtocol::CloseCode(3000);
+    QTest::newRow("Close frame with close code 3999 and no reason")
+            << QString() << QWebSocketProtocol::CloseCode(3999);
+    QTest::newRow("Close frame with close code 4000 and no reason")
+            << QString() << QWebSocketProtocol::CloseCode(4000);
+    QTest::newRow("Close frame with close code 4999 and no reason")
+            << QString() << QWebSocketProtocol::CloseCode(4999);
+
+    QTest::newRow("Close frame with no close code and no reason")
+            << QString() << QWebSocketProtocol::CloseCode(0);
 }
 
 void tst_DataProcessor::goodOpcodes_data()
 {
     QTest::addColumn<QWebSocketProtocol::OpCode>("opCode");
 
-    QTest::newRow("Frame with PING opcode") << QWebSocketProtocol::OC_PING;
-    QTest::newRow("Frame with PONG opcode") << QWebSocketProtocol::OC_PONG;
-    QTest::newRow("Frame with TEXT opcode") << QWebSocketProtocol::OC_TEXT;
-    QTest::newRow("Frame with BINARY opcode") << QWebSocketProtocol::OC_BINARY;
-    QTest::newRow("Frame with CLOSE opcode") << QWebSocketProtocol::OC_CLOSE;
+    QTest::newRow("Frame with PING opcode") << QWebSocketProtocol::OpCodePing;
+    QTest::newRow("Frame with PONG opcode") << QWebSocketProtocol::OpCodePong;
+    QTest::newRow("Frame with TEXT opcode") << QWebSocketProtocol::OpCodeText;
+    QTest::newRow("Frame with BINARY opcode") << QWebSocketProtocol::OpCodeBinary;
+    QTest::newRow("Frame with CLOSE opcode") << QWebSocketProtocol::OpCodeClose;
 }
 
 void tst_DataProcessor::goodOpcodes()
@@ -501,25 +528,33 @@ void tst_DataProcessor::goodOpcodes()
     buffer.setData(data);
     buffer.open(QIODevice::ReadOnly);
 
-    QSignalSpy errorReceivedSpy(&dataProcessor, SIGNAL(errorEncountered(QWebSocketProtocol::CloseCode,QString)));
-    QSignalSpy closeReceivedSpy(&dataProcessor, SIGNAL(closeReceived(QWebSocketProtocol::CloseCode,QString)));
-    QSignalSpy pingReceivedSpy(&dataProcessor, SIGNAL(pingReceived(QByteArray)));
-    QSignalSpy pongReceivedSpy(&dataProcessor, SIGNAL(pongReceived(QByteArray)));
-    QSignalSpy textFrameReceivedSpy(&dataProcessor, SIGNAL(textFrameReceived(QString,bool)));
-    QSignalSpy textMessageReceivedSpy(&dataProcessor, SIGNAL(textMessageReceived(QString)));
-    QSignalSpy binaryFrameReceivedSpy(&dataProcessor, SIGNAL(binaryFrameReceived(QByteArray,bool)));
-    QSignalSpy binaryMessageReceivedSpy(&dataProcessor, SIGNAL(binaryMessageReceived(QByteArray)));
+    QSignalSpy errorReceivedSpy(&dataProcessor,
+                                SIGNAL(errorEncountered(QWebSocketProtocol::CloseCode,QString)));
+    QSignalSpy closeReceivedSpy(&dataProcessor,
+                                SIGNAL(closeReceived(QWebSocketProtocol::CloseCode,QString)));
+    QSignalSpy pingReceivedSpy(&dataProcessor,
+                               SIGNAL(pingReceived(QByteArray)));
+    QSignalSpy pongReceivedSpy(&dataProcessor,
+                               SIGNAL(pongReceived(QByteArray)));
+    QSignalSpy textFrameReceivedSpy(&dataProcessor,
+                                    SIGNAL(textFrameReceived(QString,bool)));
+    QSignalSpy textMessageReceivedSpy(&dataProcessor,
+                                      SIGNAL(textMessageReceived(QString)));
+    QSignalSpy binaryFrameReceivedSpy(&dataProcessor,
+                                      SIGNAL(binaryFrameReceived(QByteArray,bool)));
+    QSignalSpy binaryMessageReceivedSpy(&dataProcessor,
+                                        SIGNAL(binaryMessageReceived(QByteArray)));
 
     dataProcessor.process(&buffer);
 
     QCOMPARE(errorReceivedSpy.count(), 0);
-    QCOMPARE(pingReceivedSpy.count(), opCode == QWebSocketProtocol::OC_PING ? 1 : 0);
-    QCOMPARE(pongReceivedSpy.count(), opCode == QWebSocketProtocol::OC_PONG ? 1 : 0);
-    QCOMPARE(closeReceivedSpy.count(), opCode == QWebSocketProtocol::OC_CLOSE ? 1 : 0);
-    QCOMPARE(textFrameReceivedSpy.count(), opCode == QWebSocketProtocol::OC_TEXT ? 1 : 0);
-    QCOMPARE(textMessageReceivedSpy.count(), opCode == QWebSocketProtocol::OC_TEXT ? 1 : 0);
-    QCOMPARE(binaryFrameReceivedSpy.count(), opCode == QWebSocketProtocol::OC_BINARY ? 1 : 0);
-    QCOMPARE(binaryMessageReceivedSpy.count(), opCode == QWebSocketProtocol::OC_BINARY ? 1 : 0);
+    QCOMPARE(pingReceivedSpy.count(), opCode == QWebSocketProtocol::OpCodePing ? 1 : 0);
+    QCOMPARE(pongReceivedSpy.count(), opCode == QWebSocketProtocol::OpCodePong ? 1 : 0);
+    QCOMPARE(closeReceivedSpy.count(), opCode == QWebSocketProtocol::OpCodeClose ? 1 : 0);
+    QCOMPARE(textFrameReceivedSpy.count(), opCode == QWebSocketProtocol::OpCodeText ? 1 : 0);
+    QCOMPARE(textMessageReceivedSpy.count(), opCode == QWebSocketProtocol::OpCodeText ? 1 : 0);
+    QCOMPARE(binaryFrameReceivedSpy.count(), opCode == QWebSocketProtocol::OpCodeBinary ? 1 : 0);
+    QCOMPARE(binaryMessageReceivedSpy.count(), opCode == QWebSocketProtocol::OpCodeBinary ? 1 : 0);
 
     buffer.close();
 }
@@ -534,7 +569,7 @@ void tst_DataProcessor::goodCloseFrame()
     quint16 swapped = qToBigEndian<quint16>(closeCode);
     const char *wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
 
-    data.append((char)(FIN | QWebSocketProtocol::OC_CLOSE));
+    data.append((char)(FIN | QWebSocketProtocol::OpCodeClose));
     if (swapped != 0)
     {
         data.append(char(payload.length() + 2)).append(wireRepresentation, 2).append(payload);
@@ -542,8 +577,8 @@ void tst_DataProcessor::goodCloseFrame()
     else
     {
         data.append(QChar::fromLatin1(0));  //payload length 0;
-        //dataprocessor emits a CC_NORMAL close code when none is present
-        closeCode = QWebSocketProtocol::CC_NORMAL;
+        //dataprocessor emits a CloseCodeNormal close code when none is present
+        closeCode = QWebSocketProtocol::CloseCodeNormal;
     }
     buffer.setData(data);
     buffer.open(QIODevice::ReadOnly);
@@ -668,9 +703,10 @@ void tst_DataProcessor::frameTooSmall()
     QWebSocketDataProcessor dataProcessor;
     QByteArray firstFrame;
 
-    firstFrame.append(quint8(QWebSocketProtocol::OC_TEXT)).append(char(1)).append(QByteArray(1, 'a'));
+    firstFrame.append(quint8(QWebSocketProtocol::OpCodeText)).append(char(1))
+            .append(QByteArray(1, 'a'));
 
-    //with nothing in the buffer, the dataProcessor should time out and the error should be CC_GOING_AWAY
+    //with nothing in the buffer, the dataProcessor should time out and the error should be CloseCodeGoingAway
     //meaning the socket will be closed
     buffer.setData(data);
     buffer.open(QIODevice::ReadOnly);
@@ -695,7 +731,8 @@ void tst_DataProcessor::frameTooSmall()
     QCOMPARE(binaryFrameSpy.count(), 0);
 
     QList<QVariant> arguments = errorSpy.takeFirst();
-    QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(), QWebSocketProtocol::CC_GOING_AWAY);
+    QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(),
+             QWebSocketProtocol::CloseCodeGoingAway);
     errorSpy.clear();
     closeSpy.clear();
     pingMessageSpy.clear();
@@ -707,7 +744,8 @@ void tst_DataProcessor::frameTooSmall()
     buffer.close();
     data.clear();
 
-    //only one byte; this is far too little; should get a time out as well and the error should be CC_GOING_AWAY
+    //only one byte; this is far too little;
+    //should get a time out as well and the error should be CloseCodeGoingAway
     //meaning the socket will be closed
     data.append(quint8('1'));   //put 1 byte in the buffer; this is too little
     buffer.setData(data);
@@ -725,7 +763,8 @@ void tst_DataProcessor::frameTooSmall()
     QCOMPARE(binaryFrameSpy.count(), 0);
 
     arguments = errorSpy.takeFirst();
-    QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(), QWebSocketProtocol::CC_GOING_AWAY);
+    QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(),
+             QWebSocketProtocol::CloseCodeGoingAway);
     buffer.close();
     errorSpy.clear();
     closeSpy.clear();
@@ -740,7 +779,7 @@ void tst_DataProcessor::frameTooSmall()
 
     {
         //text frame with final bit not set
-        data.append((char)(QWebSocketProtocol::OC_TEXT)).append(char(0x0));
+        data.append((char)(QWebSocketProtocol::OpCodeText)).append(char(0x0));
         buffer.setData(data);
         buffer.open(QIODevice::ReadOnly);
 
@@ -749,11 +788,13 @@ void tst_DataProcessor::frameTooSmall()
         buffer.close();
         data.clear();
 
-        //with nothing in the buffer, the dataProcessor should time out and the error should be CC_GOING_AWAY
+        //with nothing in the buffer,
+        //the dataProcessor should time out and the error should be CloseCodeGoingAway
         //meaning the socket will be closed
         buffer.setData(data);
         buffer.open(QIODevice::ReadOnly);
-        QSignalSpy errorSpy(&dataProcessor, SIGNAL(errorEncountered(QWebSocketProtocol::CloseCode,QString)));
+        QSignalSpy errorSpy(&dataProcessor,
+                            SIGNAL(errorEncountered(QWebSocketProtocol::CloseCode,QString)));
         dataProcessor.process(&buffer);
 
         QCOMPARE(errorSpy.count(), 1);
@@ -766,7 +807,8 @@ void tst_DataProcessor::frameTooSmall()
         QCOMPARE(binaryFrameSpy.count(), 0);
 
         QList<QVariant> arguments = errorSpy.takeFirst();
-        QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(), QWebSocketProtocol::CC_GOING_AWAY);
+        QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(),
+                 QWebSocketProtocol::CloseCodeGoingAway);
         errorSpy.clear();
         closeSpy.clear();
         pingMessageSpy.clear();
@@ -779,7 +821,7 @@ void tst_DataProcessor::frameTooSmall()
         data.clear();
 
         //text frame with final bit not set
-        data.append((char)(QWebSocketProtocol::OC_TEXT)).append(char(0x0));
+        data.append((char)(QWebSocketProtocol::OpCodeText)).append(char(0x0));
         buffer.setData(data);
         buffer.open(QIODevice::ReadOnly);
         dataProcessor.process(&buffer);
@@ -805,7 +847,8 @@ void tst_DataProcessor::frameTooSmall()
         textFrameSpy.clear();
         binaryFrameSpy.clear();
 
-        //only 1 byte follows in continuation frame; should time out with close code CC_GOING_AWAY
+        //only 1 byte follows in continuation frame;
+        //should time out with close code CloseCodeGoingAway
         data.append('a');
         buffer.setData(data);
         buffer.open(QIODevice::ReadOnly);
@@ -820,7 +863,8 @@ void tst_DataProcessor::frameTooSmall()
         QCOMPARE(textFrameSpy.count(), 0);
         QCOMPARE(binaryFrameSpy.count(), 0);
         arguments = errorSpy.takeFirst();
-        QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(), QWebSocketProtocol::CC_GOING_AWAY);
+        QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(),
+                 QWebSocketProtocol::CloseCodeGoingAway);
         buffer.close();
     }
 }
@@ -842,29 +886,29 @@ void tst_DataProcessor::frameTooBig_data()
     swapped64 = qToBigEndian<quint64>(QWebSocketDataProcessor::maxFrameSize() + 1);
     wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped64));
     QTest::newRow("Text frame with payload size > INT_MAX")
-            << quint8(FIN | QWebSocketProtocol::OC_TEXT)
+            << quint8(FIN | QWebSocketProtocol::OpCodeText)
             << quint8(127)
             << QByteArray(wireRepresentation, 8).append(QByteArray(32, 'a'))
             << false
-            << QWebSocketProtocol::CC_TOO_MUCH_DATA;
+            << QWebSocketProtocol::CloseCodeTooMuchData;
 
     swapped64 = qToBigEndian<quint64>(QWebSocketDataProcessor::maxFrameSize() + 1);
     wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped64));
     QTest::newRow("Binary frame with payload size > INT_MAX")
-            << quint8(FIN | QWebSocketProtocol::OC_BINARY)
+            << quint8(FIN | QWebSocketProtocol::OpCodeBinary)
             << quint8(127)
             << QByteArray(wireRepresentation, 8).append(QByteArray(32, 'a'))
             << false
-            << QWebSocketProtocol::CC_TOO_MUCH_DATA;
+            << QWebSocketProtocol::CloseCodeTooMuchData;
 
     swapped64 = qToBigEndian<quint64>(QWebSocketDataProcessor::maxFrameSize() + 1);
     wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped64));
     QTest::newRow("Continuation frame with payload size > INT_MAX")
-            << quint8(FIN | QWebSocketProtocol::OC_CONTINUE)
+            << quint8(FIN | QWebSocketProtocol::OpCodeContinue)
             << quint8(127)
             << QByteArray(wireRepresentation, 8).append(QByteArray(32, 'a'))
             << true
-            << QWebSocketProtocol::CC_TOO_MUCH_DATA;
+            << QWebSocketProtocol::CloseCodeTooMuchData;
 }
 
 void tst_DataProcessor::frameTooBig()
@@ -892,16 +936,16 @@ void tst_DataProcessor::invalidHeader_data()
     invalidField("RSV1, RSV2 and RSV3 set", RSV1 | RSV2 | RSV3);
 
     //invalid opcodes
-    invalidField("Invalid OpCode 3", QWebSocketProtocol::OC_RESERVED_3);
-    invalidField("Invalid OpCode 4", QWebSocketProtocol::OC_RESERVED_4);
-    invalidField("Invalid OpCode 5", QWebSocketProtocol::OC_RESERVED_5);
-    invalidField("Invalid OpCode 6", QWebSocketProtocol::OC_RESERVED_6);
-    invalidField("Invalid OpCode 7", QWebSocketProtocol::OC_RESERVED_7);
-    invalidField("Invalid OpCode B", QWebSocketProtocol::OC_RESERVED_B);
-    invalidField("Invalid OpCode C", QWebSocketProtocol::OC_RESERVED_C);
-    invalidField("Invalid OpCode D", QWebSocketProtocol::OC_RESERVED_D);
-    invalidField("Invalid OpCode E", QWebSocketProtocol::OC_RESERVED_E);
-    invalidField("Invalid OpCode F", QWebSocketProtocol::OC_RESERVED_F);
+    invalidField("Invalid OpCode 3", QWebSocketProtocol::OpCodeReserved3);
+    invalidField("Invalid OpCode 4", QWebSocketProtocol::OpCodeReserved4);
+    invalidField("Invalid OpCode 5", QWebSocketProtocol::OpCodeReserved5);
+    invalidField("Invalid OpCode 6", QWebSocketProtocol::OpCodeReserved6);
+    invalidField("Invalid OpCode 7", QWebSocketProtocol::OpCodeReserved7);
+    invalidField("Invalid OpCode B", QWebSocketProtocol::OpCodeReservedB);
+    invalidField("Invalid OpCode C", QWebSocketProtocol::OpCodeReservedC);
+    invalidField("Invalid OpCode D", QWebSocketProtocol::OpCodeReservedD);
+    invalidField("Invalid OpCode E", QWebSocketProtocol::OpCodeReservedE);
+    invalidField("Invalid OpCode F", QWebSocketProtocol::OpCodeReservedF);
 }
 
 void tst_DataProcessor::invalidHeader()
@@ -919,41 +963,41 @@ void tst_DataProcessor::invalidControlFrame_data()
 
 
     QTest::newRow("Close control frame with payload size 126")
-            << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+            << quint8(FIN | QWebSocketProtocol::OpCodeClose)
             << quint8(126)
             << QByteArray()
             << false
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow("Ping control frame with payload size 126")
-            << quint8(FIN | QWebSocketProtocol::OC_PING)
+            << quint8(FIN | QWebSocketProtocol::OpCodePing)
             << quint8(126)
             << QByteArray()
             << false
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow("Close control frame with payload size 126")
-            << quint8(FIN | QWebSocketProtocol::OC_PONG)
+            << quint8(FIN | QWebSocketProtocol::OpCodePong)
             << quint8(126)
             << QByteArray()
             << false
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
 
     QTest::newRow("Non-final close control frame (fragmented)")
-            << quint8(QWebSocketProtocol::OC_CLOSE)
+            << quint8(QWebSocketProtocol::OpCodeClose)
             << quint8(32)
             << QByteArray()
             << false
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow("Non-final ping control frame (fragmented)")
-            << quint8(QWebSocketProtocol::OC_PING)
+            << quint8(QWebSocketProtocol::OpCodePing)
             << quint8(32) << QByteArray()
             << false
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow("Non-final pong control frame (fragmented)")
-            << quint8(QWebSocketProtocol::OC_PONG)
+            << quint8(QWebSocketProtocol::OpCodePong)
             << quint8(32)
             << QByteArray()
             << false
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
 }
 
 void tst_DataProcessor::invalidControlFrame()
@@ -970,127 +1014,127 @@ void tst_DataProcessor::invalidCloseFrame_data()
     QTest::addColumn<QWebSocketProtocol::CloseCode>("expectedCloseCode");
 
     QTest::newRow("Close control frame with payload size 1")
-            << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+            << quint8(FIN | QWebSocketProtocol::OpCodeClose)
             << quint8(1)
             << QByteArray(1, 'a')
             << false
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
-    quint16 swapped = qToBigEndian<quint16>(QWebSocketProtocol::CC_ABNORMAL_DISCONNECTION);
+            << QWebSocketProtocol::CloseCodeProtocolError;
+    quint16 swapped = qToBigEndian<quint16>(QWebSocketProtocol::CloseCodeAbnormalDisconnection);
     const char *wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
 
     //Not allowed per RFC 6455 (see para 7.4.1)
     QTest::newRow("Close control frame close code ABNORMAL DISCONNECTION")
-            << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+            << quint8(FIN | QWebSocketProtocol::OpCodeClose)
             << quint8(2)
             << QByteArray(wireRepresentation, 2)
             << false
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
-    swapped = qToBigEndian<quint16>(QWebSocketProtocol::CC_MISSING_STATUS_CODE);
+            << QWebSocketProtocol::CloseCodeProtocolError;
+    swapped = qToBigEndian<quint16>(QWebSocketProtocol::CloseCodeMissingStatusCode);
     wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
     //Not allowed per RFC 6455 (see para 7.4.1)
     QTest::newRow("Close control frame close code MISSING STATUS CODE")
-            << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+            << quint8(FIN | QWebSocketProtocol::OpCodeClose)
             << quint8(2)
             << QByteArray(wireRepresentation, 2)
             << false
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     swapped = qToBigEndian<quint16>(1004);
     wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
     QTest::newRow("Close control frame close code 1004")
-            << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+            << quint8(FIN | QWebSocketProtocol::OpCodeClose)
             << quint8(2)
             << QByteArray(wireRepresentation, 2)
             << false
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
-    swapped = qToBigEndian<quint16>(QWebSocketProtocol::CC_TLS_HANDSHAKE_FAILED);
+            << QWebSocketProtocol::CloseCodeProtocolError;
+    swapped = qToBigEndian<quint16>(QWebSocketProtocol::CloseCodeTlsHandshakeFailed);
     wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
     //Not allowed per RFC 6455 (see para 7.4.1)
     QTest::newRow("Close control frame close code TLS HANDSHAKE FAILED")
-            << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+            << quint8(FIN | QWebSocketProtocol::OpCodeClose)
             << quint8(2)
             << QByteArray(wireRepresentation, 2)
             << false
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     swapped = qToBigEndian<quint16>(0);
     wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
     QTest::newRow("Close control frame close code 0")
-            << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+            << quint8(FIN | QWebSocketProtocol::OpCodeClose)
             << quint8(2)
             << QByteArray(wireRepresentation, 2)
             << false
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     swapped = qToBigEndian<quint16>(999);
     wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
     QTest::newRow("Close control frame close code 999")
-            << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+            << quint8(FIN | QWebSocketProtocol::OpCodeClose)
             << quint8(2)
             << QByteArray(wireRepresentation, 2)
             << false
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     swapped = qToBigEndian<quint16>(1012);
     wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
     QTest::newRow("Close control frame close code 1012")
-            << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+            << quint8(FIN | QWebSocketProtocol::OpCodeClose)
             << quint8(2)
             << QByteArray(wireRepresentation, 2)
             << false
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     swapped = qToBigEndian<quint16>(1013);
     wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
     QTest::newRow("Close control frame close code 1013")
-            << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+            << quint8(FIN | QWebSocketProtocol::OpCodeClose)
             << quint8(2)
             << QByteArray(wireRepresentation, 2)
             << false
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     swapped = qToBigEndian<quint16>(1014);
     wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
     QTest::newRow("Close control frame close code 1014")
-            << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+            << quint8(FIN | QWebSocketProtocol::OpCodeClose)
             << quint8(2)
             << QByteArray(wireRepresentation, 2)
             << false
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     swapped = qToBigEndian<quint16>(1100);
     wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
     QTest::newRow("Close control frame close code 1100")
-            << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+            << quint8(FIN | QWebSocketProtocol::OpCodeClose)
             << quint8(2)
             << QByteArray(wireRepresentation, 2)
             << false
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     swapped = qToBigEndian<quint16>(2000);
     wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
     QTest::newRow("Close control frame close code 2000")
-            << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+            << quint8(FIN | QWebSocketProtocol::OpCodeClose)
             << quint8(2)
             << QByteArray(wireRepresentation, 2)
             << false
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     swapped = qToBigEndian<quint16>(2999);
     wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
     QTest::newRow("Close control frame close code 2999")
-            << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+            << quint8(FIN | QWebSocketProtocol::OpCodeClose)
             << quint8(2)
             << QByteArray(wireRepresentation, 2)
             << false
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     swapped = qToBigEndian<quint16>(5000);
     wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
     QTest::newRow("Close control frame close code 5000")
-            << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+            << quint8(FIN | QWebSocketProtocol::OpCodeClose)
             << quint8(2)
             << QByteArray(wireRepresentation, 2)
             << false
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     swapped = qToBigEndian<quint16>(65535u);
     wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
     QTest::newRow("Close control frame close code 65535")
-            << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+            << quint8(FIN | QWebSocketProtocol::OpCodeClose)
             << quint8(2)
             << QByteArray(wireRepresentation, 2)
             << false
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
 }
 
 void tst_DataProcessor::invalidCloseFrame()
@@ -1301,22 +1345,22 @@ void tst_DataProcessor::incompletePayload_data()
     QTest::addColumn<bool>("isContinuationFrame");
     QTest::addColumn<QWebSocketProtocol::CloseCode>("expectedCloseCode");
 
-    incompleteFrame(QWebSocketProtocol::OC_TEXT, 125, 0);
-    incompleteFrame(QWebSocketProtocol::OC_TEXT, 64, 32);
-    incompleteFrame(QWebSocketProtocol::OC_TEXT, 256, 32);
-    incompleteFrame(QWebSocketProtocol::OC_TEXT, 128000, 32);
-    incompleteFrame(QWebSocketProtocol::OC_BINARY, 125, 0);
-    incompleteFrame(QWebSocketProtocol::OC_BINARY, 64, 32);
-    incompleteFrame(QWebSocketProtocol::OC_BINARY, 256, 32);
-    incompleteFrame(QWebSocketProtocol::OC_BINARY, 128000, 32);
-    incompleteFrame(QWebSocketProtocol::OC_CONTINUE, 125, 0);
-    incompleteFrame(QWebSocketProtocol::OC_CONTINUE, 64, 32);
-    incompleteFrame(QWebSocketProtocol::OC_CONTINUE, 256, 32);
-    incompleteFrame(QWebSocketProtocol::OC_CONTINUE, 128000, 32);
-
-    incompleteFrame(QWebSocketProtocol::OC_CLOSE, 64, 32);
-    incompleteFrame(QWebSocketProtocol::OC_PING, 64, 32);
-    incompleteFrame(QWebSocketProtocol::OC_PONG, 64, 32);
+    incompleteFrame(QWebSocketProtocol::OpCodeText, 125, 0);
+    incompleteFrame(QWebSocketProtocol::OpCodeText, 64, 32);
+    incompleteFrame(QWebSocketProtocol::OpCodeText, 256, 32);
+    incompleteFrame(QWebSocketProtocol::OpCodeText, 128000, 32);
+    incompleteFrame(QWebSocketProtocol::OpCodeBinary, 125, 0);
+    incompleteFrame(QWebSocketProtocol::OpCodeBinary, 64, 32);
+    incompleteFrame(QWebSocketProtocol::OpCodeBinary, 256, 32);
+    incompleteFrame(QWebSocketProtocol::OpCodeBinary, 128000, 32);
+    incompleteFrame(QWebSocketProtocol::OpCodeContinue, 125, 0);
+    incompleteFrame(QWebSocketProtocol::OpCodeContinue, 64, 32);
+    incompleteFrame(QWebSocketProtocol::OpCodeContinue, 256, 32);
+    incompleteFrame(QWebSocketProtocol::OpCodeContinue, 128000, 32);
+
+    incompleteFrame(QWebSocketProtocol::OpCodeClose, 64, 32);
+    incompleteFrame(QWebSocketProtocol::OpCodePing, 64, 32);
+    incompleteFrame(QWebSocketProtocol::OpCodePong, 64, 32);
 }
 
 void tst_DataProcessor::incompletePayload()
@@ -1374,7 +1418,7 @@ void tst_DataProcessor::doTest()
 
     if (isContinuationFrame)
     {
-        data.append(quint8(QWebSocketProtocol::OC_TEXT)).append(char(1)).append(QByteArray(1, 'a'));
+        data.append(quint8(QWebSocketProtocol::OpCodeText)).append(char(1)).append(QByteArray(1, 'a'));
     }
     data.append(firstByte).append(secondByte);
     data.append(payload);
@@ -1434,82 +1478,82 @@ QString tst_DataProcessor::opCodeToString(quint8 opCode)
     QString frameType;
     switch (opCode)
     {
-        case QWebSocketProtocol::OC_BINARY:
+        case QWebSocketProtocol::OpCodeBinary:
         {
             frameType = QStringLiteral("Binary");
             break;
         }
-        case QWebSocketProtocol::OC_TEXT:
+        case QWebSocketProtocol::OpCodeText:
         {
             frameType = QStringLiteral("Text");
             break;
         }
-        case QWebSocketProtocol::OC_PING:
+        case QWebSocketProtocol::OpCodePing:
         {
             frameType = QStringLiteral("Ping");
             break;
         }
-        case QWebSocketProtocol::OC_PONG:
+        case QWebSocketProtocol::OpCodePong:
         {
             frameType = QStringLiteral("Pong");
             break;
         }
-        case QWebSocketProtocol::OC_CLOSE:
+        case QWebSocketProtocol::OpCodeClose:
         {
             frameType = QStringLiteral("Close");
             break;
         }
-        case QWebSocketProtocol::OC_CONTINUE:
+        case QWebSocketProtocol::OpCodeContinue:
         {
             frameType = QStringLiteral("Continuation");
             break;
         }
-        case QWebSocketProtocol::OC_RESERVED_3:
+        case QWebSocketProtocol::OpCodeReserved3:
         {
             frameType = QStringLiteral("Reserved3");
             break;
         }
-        case QWebSocketProtocol::OC_RESERVED_4:
+        case QWebSocketProtocol::OpCodeReserved4:
         {
             frameType = QStringLiteral("Reserved5");
             break;
         }
-        case QWebSocketProtocol::OC_RESERVED_5:
+        case QWebSocketProtocol::OpCodeReserved5:
         {
             frameType = QStringLiteral("Reserved5");
             break;
         }
-        case QWebSocketProtocol::OC_RESERVED_6:
+        case QWebSocketProtocol::OpCodeReserved6:
         {
             frameType = QStringLiteral("Reserved6");
             break;
         }
-        case QWebSocketProtocol::OC_RESERVED_7:
+        case QWebSocketProtocol::OpCodeReserved7:
         {
             frameType = QStringLiteral("Reserved7");
             break;
         }
-        case QWebSocketProtocol::OC_RESERVED_B:
+        case QWebSocketProtocol::OpCodeReservedB:
         {
             frameType = QStringLiteral("ReservedB");
             break;
         }
-        case QWebSocketProtocol::OC_RESERVED_C:
+        case QWebSocketProtocol::OpCodeReservedC:
         {
             frameType = QStringLiteral("ReservedC");
             break;
         }
-        case QWebSocketProtocol::OC_RESERVED_D:
+        case QWebSocketProtocol::OpCodeReservedD:
         {
             frameType = QStringLiteral("ReservedD");
             break;
         }
-        case QWebSocketProtocol::OC_RESERVED_E:
+        case QWebSocketProtocol::OpCodeReservedE:
         {
             frameType = QStringLiteral("ReservedE");
             break;
         }
-        case QWebSocketProtocol::OC_RESERVED_F:
+        case QWebSocketProtocol::OpCodeReservedF:
         {
             frameType = QStringLiteral("ReservedF");
             break;
@@ -1529,25 +1573,25 @@ void tst_DataProcessor::minimumSize16Bit(quint16 sizeInBytes)
     const char *wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped16));
     QTest::newRow(QStringLiteral("Text frame with payload size %1, represented in 2 bytes")
                   .arg(sizeInBytes).toLatin1().constData())
-            << quint8(FIN | QWebSocketProtocol::OC_TEXT)
+            << quint8(FIN | QWebSocketProtocol::OpCodeText)
             << quint8(126)
             << QByteArray(wireRepresentation, 2)
             << false
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow(QStringLiteral("Binary frame with payload size %1, represented in 2 bytes")
                   .arg(sizeInBytes).toLatin1().constBegin())
-            << quint8(FIN | QWebSocketProtocol::OC_BINARY)
+            << quint8(FIN | QWebSocketProtocol::OpCodeBinary)
             << quint8(126)
             << QByteArray(wireRepresentation, 2)
             << false
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow(QStringLiteral("Continuation frame with payload size %1, represented in 2 bytes")
                   .arg(sizeInBytes).toLatin1().constData())
-            << quint8(FIN | QWebSocketProtocol::OC_CONTINUE)
+            << quint8(FIN | QWebSocketProtocol::OpCodeContinue)
             << quint8(126)
             << QByteArray(wireRepresentation, 2)
             << true
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
 }
 
 void tst_DataProcessor::minimumSize64Bit(quint64 sizeInBytes)
@@ -1557,27 +1601,27 @@ void tst_DataProcessor::minimumSize64Bit(quint64 sizeInBytes)
 
     QTest::newRow(QStringLiteral("Text frame with payload size %1, represented in 8 bytes")
                   .arg(sizeInBytes).toLatin1().constData())
-            << quint8(FIN | QWebSocketProtocol::OC_TEXT)
+            << quint8(FIN | QWebSocketProtocol::OpCodeText)
             << quint8(127)
             << QByteArray(wireRepresentation, 8)
             << false
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
 
     QTest::newRow(QStringLiteral("Binary frame with payload size %1, represented in 8 bytes")
                   .arg(sizeInBytes).toLatin1().constData())
-            << quint8(FIN | QWebSocketProtocol::OC_BINARY)
+            << quint8(FIN | QWebSocketProtocol::OpCodeBinary)
             << quint8(127)
             << QByteArray(wireRepresentation, 8)
             << false
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
 
     QTest::newRow(QStringLiteral("Continuation frame with payload size %1, represented in 8 bytes")
                   .arg(sizeInBytes).toLatin1().constData())
-            << quint8(FIN | QWebSocketProtocol::OC_CONTINUE)
+            << quint8(FIN | QWebSocketProtocol::OpCodeContinue)
             << quint8(127)
             << QByteArray(wireRepresentation, 8)
             << true
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
 }
 
 void tst_DataProcessor::invalidUTF8(const char *dataTag, const char *utf8Sequence, bool isCloseFrame)
@@ -1586,33 +1630,33 @@ void tst_DataProcessor::invalidUTF8(const char *dataTag, const char *utf8Sequenc
 
     if (isCloseFrame)
     {
-        quint16 closeCode = qToBigEndian<quint16>(QWebSocketProtocol::CC_NORMAL);
+        quint16 closeCode = qToBigEndian<quint16>(QWebSocketProtocol::CloseCodeNormal);
         const char *wireRepresentation = static_cast<const char *>(static_cast<const void *>(&closeCode));
         QTest::newRow(QStringLiteral("Close frame with invalid UTF8-sequence: %1")
                       .arg(dataTag).toLatin1().constData())
-                << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+                << quint8(FIN | QWebSocketProtocol::OpCodeClose)
                 << quint8(payload.length() + 2)
                 << QByteArray(wireRepresentation, 2).append(payload)
                 << false
-                << QWebSocketProtocol::CC_WRONG_DATATYPE;
+                << QWebSocketProtocol::CloseCodeWrongDatatype;
     }
     else
     {
         QTest::newRow(QStringLiteral("Text frame with invalid UTF8-sequence: %1")
                       .arg(dataTag).toLatin1().constData())
-                << quint8(FIN | QWebSocketProtocol::OC_TEXT)
+                << quint8(FIN | QWebSocketProtocol::OpCodeText)
                 << quint8(payload.length())
                 << payload
                 << false
-                << QWebSocketProtocol::CC_WRONG_DATATYPE;
+                << QWebSocketProtocol::CloseCodeWrongDatatype;
 
         QTest::newRow(QStringLiteral("Continuation text frame with invalid UTF8-sequence: %1")
                       .arg(dataTag).toLatin1().constData())
-                << quint8(FIN | QWebSocketProtocol::OC_CONTINUE)
+                << quint8(FIN | QWebSocketProtocol::OpCodeContinue)
                 << quint8(payload.length())
                 << payload
                 << true
-                << QWebSocketProtocol::CC_WRONG_DATATYPE;
+                << QWebSocketProtocol::CloseCodeWrongDatatype;
     }
 }
 
@@ -1622,13 +1666,13 @@ void tst_DataProcessor::invalidField(const char *dataTag, quint8 invalidFieldVal
                            << quint8(0x00)
                            << QByteArray()
                            << false
-                           << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+                           << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow(QString::fromLatin1(dataTag).append(" with continuation frame").toLatin1().constData())
                             << quint8(FIN | invalidFieldValue)
                             << quint8(0x00)
                             << QByteArray()
                             << true
-                            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+                            << QWebSocketProtocol::CloseCodeProtocolError;
 }
 
 void tst_DataProcessor::incompleteFrame(quint8 controlCode, quint64 indicatedSize, quint64 actualPayloadSize)
@@ -1646,8 +1690,8 @@ void tst_DataProcessor::incompleteFrame(quint8 controlCode, quint64 indicatedSiz
                 << quint8(FIN | controlCode)
                 << quint8(indicatedSize)
                 << firstFrame.append(QByteArray(actualPayloadSize, 'a'))
-                << (controlCode == QWebSocketProtocol::OC_CONTINUE)
-                << QWebSocketProtocol::CC_GOING_AWAY;
+                << (controlCode == QWebSocketProtocol::OpCodeContinue)
+                << QWebSocketProtocol::CloseCodeGoingAway;
     }
     else if (indicatedSize <= 0xFFFFu)
     {
@@ -1658,8 +1702,8 @@ void tst_DataProcessor::incompleteFrame(quint8 controlCode, quint64 indicatedSiz
                 << quint8(FIN | controlCode)
                 << quint8(126)
                 << firstFrame.append(QByteArray(wireRepresentation, 2).append(QByteArray(actualPayloadSize, 'a')))
-                << (controlCode == QWebSocketProtocol::OC_CONTINUE)
-                << QWebSocketProtocol::CC_GOING_AWAY;
+                << (controlCode == QWebSocketProtocol::OpCodeContinue)
+                << QWebSocketProtocol::CloseCodeGoingAway;
     }
     else
     {
@@ -1670,8 +1714,8 @@ void tst_DataProcessor::incompleteFrame(quint8 controlCode, quint64 indicatedSiz
                 << quint8(FIN | controlCode)
                 << quint8(127)
                 << firstFrame.append(QByteArray(wireRepresentation, 8).append(QByteArray(actualPayloadSize, 'a')))
-                << (controlCode == QWebSocketProtocol::OC_CONTINUE)
-                << QWebSocketProtocol::CC_GOING_AWAY;
+                << (controlCode == QWebSocketProtocol::OpCodeContinue)
+                << QWebSocketProtocol::CloseCodeGoingAway;
     }
 }
 
@@ -1681,14 +1725,14 @@ void tst_DataProcessor::nonCharacterSequence(const char *sequence)
 
     QTest::newRow(QStringLiteral("Text frame with payload containing the non-control character sequence 0x%1")
                   .arg(QString::fromLocal8Bit(sequence)).toLatin1().constData())
-            << quint8(FIN | QWebSocketProtocol::OC_TEXT)
+            << quint8(FIN | QWebSocketProtocol::OpCodeText)
             << quint8(utf8Sequence.size())
             << utf8Sequence
             << false;
 
     QTest::newRow(QStringLiteral("Continuation frame with payload containing the non-control character sequence 0x%1")
                   .arg(QString::fromLocal8Bit(sequence)).toLatin1().constData())
-            << quint8(FIN | QWebSocketProtocol::OC_CONTINUE)
+            << quint8(FIN | QWebSocketProtocol::OpCodeContinue)
             << quint8(utf8Sequence.size())
             << utf8Sequence
             << true;
@@ -1698,25 +1742,25 @@ void tst_DataProcessor::insertIncompleteSizeFieldTest(quint8 payloadCode, quint8
 {
     QTest::newRow(QStringLiteral("Text frame with payload size %1, with %2 bytes following.")
                   .arg(payloadCode).arg(numBytesFollowing).toLatin1().constData())
-            << quint8(FIN | QWebSocketProtocol::OC_TEXT)
+            << quint8(FIN | QWebSocketProtocol::OpCodeText)
             << quint8(payloadCode)
             << QByteArray(numBytesFollowing, quint8(1))
             << false
-            << QWebSocketProtocol::CC_GOING_AWAY;
+            << QWebSocketProtocol::CloseCodeGoingAway;
     QTest::newRow(QStringLiteral("Binary frame with payload size %1, with %2 bytes following.")
                   .arg(payloadCode).arg(numBytesFollowing).toLatin1().constData())
-            << quint8(FIN | QWebSocketProtocol::OC_BINARY)
+            << quint8(FIN | QWebSocketProtocol::OpCodeBinary)
             << quint8(payloadCode)
             << QByteArray(numBytesFollowing, quint8(1))
             << false
-            << QWebSocketProtocol::CC_GOING_AWAY;
+            << QWebSocketProtocol::CloseCodeGoingAway;
     QTest::newRow(QStringLiteral("Continuation frame with payload size %1, with %2 bytes following.")
                   .arg(payloadCode).arg(numBytesFollowing).toLatin1().constData())
-            << quint8(FIN | QWebSocketProtocol::OC_CONTINUE)
+            << quint8(FIN | QWebSocketProtocol::OpCodeContinue)
             << quint8(payloadCode)
             << QByteArray(numBytesFollowing, quint8(1))
             << true
-            << QWebSocketProtocol::CC_GOING_AWAY;
+            << QWebSocketProtocol::CloseCodeGoingAway;
 }
 
 QTEST_MAIN(tst_DataProcessor)
diff --git a/tests/auto/handshakerequest/tst_handshakerequest.cpp b/tests/auto/handshakerequest/tst_handshakerequest.cpp
index 71de7b4..a49e5f2 100644
--- a/tests/auto/handshakerequest/tst_handshakerequest.cpp
+++ b/tests/auto/handshakerequest/tst_handshakerequest.cpp
@@ -252,7 +252,7 @@ void tst_HandshakeRequest::tst_multipleValuesInConnectionHeader()
     QCOMPARE(request.host(), QStringLiteral("foo.com"));
     QCOMPARE(request.resourceName().length(), 5);
     QCOMPARE(request.versions().length(), 1);
-    QCOMPARE(request.versions().at(0), QWebSocketProtocol::V_13);
+    QCOMPARE(request.versions().at(0), QWebSocketProtocol::Version13);
 }
 
 void tst_HandshakeRequest::tst_multipleVersions()
@@ -288,7 +288,7 @@ void tst_HandshakeRequest::tst_multipleVersions()
     QCOMPARE(request.resourceName().length(), 5);
     QCOMPARE(request.versions().length(), 6);
     //should be 13 since the list is ordered in decreasing order
-    QCOMPARE(request.versions().at(0), QWebSocketProtocol::V_13);
+    QCOMPARE(request.versions().at(0), QWebSocketProtocol::Version13);
 }
 
 QTEST_MAIN(tst_HandshakeRequest)
diff --git a/tests/auto/websocketframe/tst_websocketframe.cpp b/tests/auto/websocketframe/tst_websocketframe.cpp
index 46a360a..36686c5 100644
--- a/tests/auto/websocketframe/tst_websocketframe.cpp
+++ b/tests/auto/websocketframe/tst_websocketframe.cpp
@@ -85,7 +85,7 @@ private:
 
 FrameHelper::FrameHelper() :
     m_rsv1(0), m_rsv2(0), m_rsv3(0),
-    m_mask(0), m_opCode(QWebSocketProtocol::OC_RESERVED_3),
+    m_mask(0), m_opCode(QWebSocketProtocol::OpCodeReserved3),
     m_payload(), m_isFinalFrame(false)
 {}
 
@@ -201,7 +201,7 @@ void tst_WebSocketFrame::tst_copyConstructorAndAssignment()
     frameHelper.setRsv3(0);
     frameHelper.setFinalFrame(true);
     frameHelper.setMask(1234u);
-    frameHelper.setOpCode(QWebSocketProtocol::OC_BINARY);
+    frameHelper.setOpCode(QWebSocketProtocol::OpCodeBinary);
     frameHelper.setPayload(QByteArray("12345"));
 
     QByteArray payload = frameHelper.wireRepresentation();
@@ -263,54 +263,54 @@ void tst_WebSocketFrame::tst_goodFrames_data()
 
     QTest::newRow("Non masked final text frame with small payload")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_TEXT
+            << 0U << QWebSocketProtocol::OpCodeText
             << true << QStringLiteral("Hello world!").toUtf8()
             << false << true << false;
     QTest::newRow("Non masked final binary frame with small payload")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_BINARY
+            << 0U << QWebSocketProtocol::OpCodeBinary
             << true << QByteArrayLiteral("\x00\x01\x02\x03\x04")
             << false << true << false;
     QTest::newRow("Non masked final text frame with no payload")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_TEXT
+            << 0U << QWebSocketProtocol::OpCodeText
             << true << QByteArray()
             << false << true << false;
     QTest::newRow("Non masked final binary frame with no payload")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_BINARY
+            << 0U << QWebSocketProtocol::OpCodeBinary
             << true << QByteArray()
             << false << true << false;
 
     QTest::newRow("Non masked final close frame with small payload")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_CLOSE
+            << 0U << QWebSocketProtocol::OpCodeClose
             << true << QStringLiteral("Hello world!").toUtf8()
             << true << false << false;
     QTest::newRow("Non masked final close frame with no payload")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_CLOSE
+            << 0U << QWebSocketProtocol::OpCodeClose
             << true << QByteArray()
             << true << false << false;
     QTest::newRow("Non masked final ping frame with small payload")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_PING
+            << 0U << QWebSocketProtocol::OpCodePing
             << true << QStringLiteral("Hello world!").toUtf8()
             << true << false << false;
     QTest::newRow("Non masked final pong frame with no payload")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_PONG
+            << 0U << QWebSocketProtocol::OpCodePong
             << true << QByteArray()
             << true << false << false;
 
     QTest::newRow("Non masked final continuation frame with small payload")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_CONTINUE
+            << 0U << QWebSocketProtocol::OpCodeContinue
             << true << QStringLiteral("Hello world!").toUtf8()
             << false << true << true;
     QTest::newRow("Non masked non-final continuation frame with small payload")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_CONTINUE
+            << 0U << QWebSocketProtocol::OpCodeContinue
             << false << QStringLiteral("Hello world!").toUtf8()
             << false << true << true;
 }
@@ -370,116 +370,116 @@ void tst_WebSocketFrame::tst_invalidFrames_data()
 
     QTest::newRow("RSV1 != 0")
             << 1 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_TEXT
+            << 0U << QWebSocketProtocol::OpCodeText
             << true << QStringLiteral("Hello world!").toUtf8()
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow("RSV2 != 0")
             << 0 << 1 << 0
-            << 0U << QWebSocketProtocol::OC_TEXT
+            << 0U << QWebSocketProtocol::OpCodeText
             << true << QStringLiteral("Hello world!").toUtf8()
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow("RSV3 != 0")
             << 0 << 0 << 1
-            << 0U << QWebSocketProtocol::OC_TEXT
+            << 0U << QWebSocketProtocol::OpCodeText
             << true << QStringLiteral("Hello world!").toUtf8()
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow("RSV1 != 0 and RSV2 != 0")
             << 1 << 1 << 0
-            << 0U << QWebSocketProtocol::OC_TEXT
+            << 0U << QWebSocketProtocol::OpCodeText
             << true << QStringLiteral("Hello world!").toUtf8()
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow("RSV1 != 0 and RSV3 != 0")
             << 1 << 0 << 1
-            << 0U << QWebSocketProtocol::OC_TEXT
+            << 0U << QWebSocketProtocol::OpCodeText
             << true << QStringLiteral("Hello world!").toUtf8()
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow("RSV2 != 0 and RSV3 != 0")
             << 0 << 1 << 1
-            << 0U << QWebSocketProtocol::OC_TEXT
+            << 0U << QWebSocketProtocol::OpCodeText
             << true << QStringLiteral("Hello world!").toUtf8()
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
 
     QTest::newRow("Reserved OpCode 3")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_RESERVED_3
+            << 0U << QWebSocketProtocol::OpCodeReserved3
             << true << QStringLiteral("Hello world!").toUtf8()
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow("Reserved OpCode 4")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_RESERVED_4
+            << 0U << QWebSocketProtocol::OpCodeReserved4
             << true << QStringLiteral("Hello world!").toUtf8()
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow("Reserved OpCode 5")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_RESERVED_5
+            << 0U << QWebSocketProtocol::OpCodeReserved5
             << true << QStringLiteral("Hello world!").toUtf8()
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow("Reserved OpCode 6")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_RESERVED_6
+            << 0U << QWebSocketProtocol::OpCodeReserved6
             << true << QStringLiteral("Hello world!").toUtf8()
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow("Reserved OpCode 7")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_RESERVED_7
+            << 0U << QWebSocketProtocol::OpCodeReserved7
             << true << QStringLiteral("Hello world!").toUtf8()
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow("Reserved OpCode B")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_RESERVED_B
+            << 0U << QWebSocketProtocol::OpCodeReservedB
             << true << QStringLiteral("Hello world!").toUtf8()
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow("Reserved OpCode C")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_RESERVED_C
+            << 0U << QWebSocketProtocol::OpCodeReservedC
             << true << QStringLiteral("Hello world!").toUtf8()
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow("Reserved OpCode D")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_RESERVED_D
+            << 0U << QWebSocketProtocol::OpCodeReservedD
             << true << QStringLiteral("Hello world!").toUtf8()
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow("Reserved OpCode E")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_RESERVED_E
+            << 0U << QWebSocketProtocol::OpCodeReservedE
             << true << QStringLiteral("Hello world!").toUtf8()
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow("Reserved OpCode F")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_RESERVED_F
+            << 0U << QWebSocketProtocol::OpCodeReservedF
             << true << QStringLiteral("Hello world!").toUtf8()
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
 
     QTest::newRow("Close Frame with payload > 125 bytes")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_CLOSE
+            << 0U << QWebSocketProtocol::OpCodeClose
             << true << QString(126, 'a').toUtf8()
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow("Non-final Close Frame")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_CLOSE
+            << 0U << QWebSocketProtocol::OpCodeClose
             << false << QString(126, 'a').toUtf8()
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow("Ping Frame with payload > 125 bytes")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_PING
+            << 0U << QWebSocketProtocol::OpCodePing
             << true << QString(126, 'a').toUtf8()
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow("Non-final Ping Frame")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_PING
+            << 0U << QWebSocketProtocol::OpCodePing
             << false << QString(126, 'a').toUtf8()
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow("Pong Frame with payload > 125 bytes")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_PONG
+            << 0U << QWebSocketProtocol::OpCodePong
             << true << QString(126, 'a').toUtf8()
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
     QTest::newRow("Non-final Pong Frame")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_PONG
+            << 0U << QWebSocketProtocol::OpCodePong
             << false << QString(126, 'a').toUtf8()
-            << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+            << QWebSocketProtocol::CloseCodeProtocolError;
 }
 
 void tst_WebSocketFrame::tst_invalidFrames()
@@ -520,9 +520,9 @@ void tst_WebSocketFrame::tst_invalidFrames()
  *
     QTest::newRow("Frame Too Big")
             << 0 << 0 << 0
-            << 0U << QWebSocketProtocol::OC_TEXT
+            << 0U << QWebSocketProtocol::OpCodeText
             << true << QString(MAX_FRAME_SIZE_IN_BYTES + 1, 'a').toUtf8()
-            << QWebSocketProtocol::CC_TOO_MUCH_DATA;
+            << QWebSocketProtocol::CloseCodeTooMuchData;
 
  */
 void tst_WebSocketFrame::tst_malformedFrames_data()
@@ -531,13 +531,13 @@ void tst_WebSocketFrame::tst_malformedFrames_data()
     QTest::addColumn<QWebSocketProtocol::CloseCode>("expectedError");
 
     //too little data
-    QTest::newRow("No data") << QByteArray() << QWebSocketProtocol::CC_GOING_AWAY;
+    QTest::newRow("No data") << QByteArray() << QWebSocketProtocol::CloseCodeGoingAway;
     FrameHelper helper;
     helper.setRsv1(0);
     helper.setRsv2(0);
     helper.setRsv3(0);
     helper.setMask(0U);
-    helper.setOpCode(QWebSocketProtocol::OC_TEXT);
+    helper.setOpCode(QWebSocketProtocol::OpCodeText);
     helper.setFinalFrame(true);
     helper.setPayload(QString(10, 'a').toUtf8());
     QByteArray wireRep = helper.wireRepresentation();
@@ -548,7 +548,7 @@ void tst_WebSocketFrame::tst_malformedFrames_data()
     {
         QTest::newRow(QStringLiteral("Header too small - %1 byte(s)").arg(i).toLatin1().constData())
                 << wireRep.left(i)
-                << QWebSocketProtocol::CC_GOING_AWAY;
+                << QWebSocketProtocol::CloseCodeGoingAway;
     }
     //too much data
     {
@@ -558,7 +558,7 @@ void tst_WebSocketFrame::tst_malformedFrames_data()
         qToBigEndian<quint64>(payloadSize, swapped);
         QTest::newRow("Frame too big")
                 << wireRep.left(1).append(bigpayloadIndicator).append(reinterpret_cast<char *>(swapped), 8)
-                << QWebSocketProtocol::CC_TOO_MUCH_DATA;
+                << QWebSocketProtocol::CloseCodeTooMuchData;
     }
     //invalid size field
     {
@@ -568,13 +568,13 @@ void tst_WebSocketFrame::tst_malformedFrames_data()
         qToBigEndian<quint64>(payloadSize, swapped);
         QTest::newRow("Highest bit of payload length is set")
                 << wireRep.left(1).append(bigpayloadIndicator).append(reinterpret_cast<char *>(swapped), 8)
-                << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+                << QWebSocketProtocol::CloseCodeProtocolError;
 
         payloadSize = 256;
         qToBigEndian<quint64>(payloadSize, swapped);
         QTest::newRow("Overlong 64-bit size field; should be 16-bit")
                 << wireRep.left(1).append(bigpayloadIndicator).append(reinterpret_cast<char *>(swapped), 8)
-                << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+                << QWebSocketProtocol::CloseCodeProtocolError;
     }
     //overlong size field
     {
@@ -584,7 +584,7 @@ void tst_WebSocketFrame::tst_malformedFrames_data()
         qToBigEndian<quint16>(payloadSize, swapped);
         QTest::newRow("Overlong 16-bit size field")
                 << wireRep.left(1).append(largepayloadIndicator).append(reinterpret_cast<char *>(swapped), 2)
-                << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+                << QWebSocketProtocol::CloseCodeProtocolError;
     }
     {
         const char bigpayloadIndicator = char(127);
@@ -593,13 +593,13 @@ void tst_WebSocketFrame::tst_malformedFrames_data()
         qToBigEndian<quint64>(payloadSize, swapped);
         QTest::newRow("Overlong 64-bit size field; should be 7-bit")
                 << wireRep.left(1).append(bigpayloadIndicator).append(reinterpret_cast<char *>(swapped), 8)
-                << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+                << QWebSocketProtocol::CloseCodeProtocolError;
 
         payloadSize = 256;
         qToBigEndian<quint64>(payloadSize, swapped);
         QTest::newRow("Overlong 64-bit size field; should be 16-bit")
                 << wireRep.left(1).append(bigpayloadIndicator).append(reinterpret_cast<char *>(swapped), 8)
-                << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+                << QWebSocketProtocol::CloseCodeProtocolError;
     }
 }
 
diff --git a/tests/auto/websocketprotocol/tst_websocketprotocol.cpp b/tests/auto/websocketprotocol/tst_websocketprotocol.cpp
index fa3177c..c092afa 100644
--- a/tests/auto/websocketprotocol/tst_websocketprotocol.cpp
+++ b/tests/auto/websocketprotocol/tst_websocketprotocol.cpp
@@ -128,22 +128,22 @@ void tst_WebSocketProtocol::tst_opCodes_data()
     QTest::addColumn<QWebSocketProtocol::OpCode>("opCode");
     QTest::addColumn<bool>("isReserved");
 
-    QTest::newRow("OC_BINARY") << QWebSocketProtocol::OC_BINARY << false;
-    QTest::newRow("OC_CLOSE") << QWebSocketProtocol::OC_CLOSE << false;
-    QTest::newRow("OC_CONTINUE") << QWebSocketProtocol::OC_CONTINUE << false;
-    QTest::newRow("OC_PING") << QWebSocketProtocol::OC_PING << false;
-    QTest::newRow("OC_PONG") << QWebSocketProtocol::OC_PONG << false;
-    QTest::newRow("OC_RESERVED3") << QWebSocketProtocol::OC_RESERVED_3 << true;
-    QTest::newRow("OC_RESERVED4") << QWebSocketProtocol::OC_RESERVED_4 << true;
-    QTest::newRow("OC_RESERVED5") << QWebSocketProtocol::OC_RESERVED_5 << true;
-    QTest::newRow("OC_RESERVED6") << QWebSocketProtocol::OC_RESERVED_6 << true;
-    QTest::newRow("OC_RESERVED7") << QWebSocketProtocol::OC_RESERVED_7 << true;
-    QTest::newRow("OC_RESERVEDB") << QWebSocketProtocol::OC_RESERVED_B << true;
-    QTest::newRow("OC_RESERVEDC") << QWebSocketProtocol::OC_RESERVED_C << true;
-    QTest::newRow("OC_RESERVEDD") << QWebSocketProtocol::OC_RESERVED_D << true;
-    QTest::newRow("OC_RESERVEDE") << QWebSocketProtocol::OC_RESERVED_E << true;
-    QTest::newRow("OC_RESERVEDF") << QWebSocketProtocol::OC_RESERVED_F << true;
-    QTest::newRow("OC_TEXT") << QWebSocketProtocol::OC_TEXT << false;
+    QTest::newRow("OpCodeBinary")       << QWebSocketProtocol::OpCodeBinary << false;
+    QTest::newRow("OpCodeClose")        << QWebSocketProtocol::OpCodeClose << false;
+    QTest::newRow("OpCodeContinue")     << QWebSocketProtocol::OpCodeContinue << false;
+    QTest::newRow("OpCodePing")         << QWebSocketProtocol::OpCodePing << false;
+    QTest::newRow("OpCodePong")         << QWebSocketProtocol::OpCodePong << false;
+    QTest::newRow("OpCodeReserved3")    << QWebSocketProtocol::OpCodeReserved3 << true;
+    QTest::newRow("OpCodeReserved4")    << QWebSocketProtocol::OpCodeReserved4 << true;
+    QTest::newRow("OpCodeReserved5")    << QWebSocketProtocol::OpCodeReserved5 << true;
+    QTest::newRow("OpCodeReserved6")    << QWebSocketProtocol::OpCodeReserved6 << true;
+    QTest::newRow("OpCodeReserved7")    << QWebSocketProtocol::OpCodeReserved7 << true;
+    QTest::newRow("OpCodeReserved8")    << QWebSocketProtocol::OpCodeReservedB << true;
+    QTest::newRow("OpCodeReservedC")    << QWebSocketProtocol::OpCodeReservedC << true;
+    QTest::newRow("OpCodeReservedD")    << QWebSocketProtocol::OpCodeReservedD << true;
+    QTest::newRow("OpCodeReservedE")    << QWebSocketProtocol::OpCodeReservedE << true;
+    QTest::newRow("OpCodeReservedF")    << QWebSocketProtocol::OpCodeReservedF << true;
+    QTest::newRow("OpCodeText")         << QWebSocketProtocol::OpCodeText << false;
 }
 
 void tst_WebSocketProtocol::tst_opCodes()