~evan-nelson/armagetronad/armagetronad+pcm

« back to all changes in this revision

Viewing changes to src/test/chat_prefix_test.cpp

Attempting to create a timeout for PLAYER_CENTER_MESSAGE.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
#include <libxml/xmlreader.h>
2
 
#include <iostream>
3
 
 
4
 
#include "eChat.h"
5
 
#include "tString.h"
6
 
#include "ePlayer.h"
7
 
 
8
 
struct Stats
9
 
{
10
 
    Stats() : sessions( 0 ), chats( 0 ), chatsThrough( 0 ), foundPrefixes( 0 ) { }
11
 
    int sessions;
12
 
    int chats;
13
 
    int chatsThrough;
14
 
    int foundPrefixes;
15
 
    
16
 
    static Stats stats;
17
 
};
18
 
 
19
 
Stats Stats::stats = Stats();
20
 
 
21
 
 
22
 
tString ConvertXMLString( const xmlChar *x )
23
 
{
24
 
    return tString( (const char *)x );
25
 
}
26
 
 
27
 
struct Session
28
 
{
29
 
    Session( int lineNumber ) :lineNumber_( lineNumber ), player_(), chatlog_() { }
30
 
    
31
 
    void AddSaid( const tString & say , nTimeRolling time )
32
 
    {
33
 
        eChatSaidEntry entry( say, time, eChatMessageType_Public );
34
 
        chatlog_.push_back( entry );
35
 
    }
36
 
    
37
 
    int lineNumber_;
38
 
    tString player_;
39
 
    std::vector< eChatSaidEntry > chatlog_;
40
 
};
41
 
 
42
 
void TestSession( const Session & session )
43
 
{
44
 
    Stats::stats.sessions += 1;
45
 
    
46
 
    ePlayerNetID player;
47
 
    player.SetName( session.player_ );
48
 
    
49
 
    for ( size_t i = 0; i < session.chatlog_.size(); i++)
50
 
    {
51
 
        Stats::stats.chats += 1;
52
 
        
53
 
        const eChatSaidEntry & entry = session.chatlog_[i];
54
 
        
55
 
        eChatPrefixSpamTester tester( &player, entry );
56
 
        
57
 
        tString out;
58
 
        nTimeRolling timeOut;
59
 
        eChatPrefixSpamType typeOut;
60
 
        
61
 
        if ( tester.Check( out, timeOut, typeOut ) )
62
 
        {
63
 
            if ( typeOut != eChatPrefixSpamType_Known )
64
 
            {
65
 
                std::cout << "Found from session starting at line number " << session.lineNumber_ << "\n\n";
66
 
                Stats::stats.foundPrefixes += 1;
67
 
            }
68
 
        }
69
 
        else
70
 
        {
71
 
            Stats::stats.chatsThrough += 1;
72
 
            player.lastSaid_.AddSaid( entry );
73
 
        }
74
 
    }
75
 
}
76
 
 
77
 
void ProcessNode( xmlTextReaderPtr reader )
78
 
{
79
 
    static Session currentSession( 0 );
80
 
    
81
 
    int type = xmlTextReaderNodeType( reader );
82
 
    
83
 
    if ( type == XML_READER_TYPE_END_ELEMENT && xmlStrEqual( xmlTextReaderConstName( reader ), BAD_CAST "Session" ) )
84
 
    {
85
 
        TestSession( currentSession );
86
 
    }
87
 
    
88
 
    if ( type != XML_READER_TYPE_ELEMENT )
89
 
        return;
90
 
    
91
 
    if ( xmlStrEqual( xmlTextReaderConstName( reader ), BAD_CAST "Session" ) )
92
 
    {
93
 
        currentSession = Session( xmlTextReaderGetParserLineNumber( reader ) );
94
 
    }
95
 
    else if ( xmlStrEqual( xmlTextReaderConstName( reader ), BAD_CAST "Player" ) )
96
 
    {
97
 
        xmlChar *xmlPlayer = xmlTextReaderReadString( reader );
98
 
        currentSession.player_ = ConvertXMLString( xmlPlayer );
99
 
        xmlFree( xmlPlayer );
100
 
    }
101
 
    else if ( xmlStrEqual( xmlTextReaderConstName( reader ), BAD_CAST "Said" ) )
102
 
    {
103
 
        xmlChar *xmlTime = xmlTextReaderGetAttribute( reader, BAD_CAST "time" );
104
 
        xmlChar *xmlSaid = xmlTextReaderReadString( reader );
105
 
        
106
 
        long time = atol( (const char *)xmlTime );
107
 
        tString say = ConvertXMLString( xmlSaid );
108
 
        
109
 
        currentSession.AddSaid( say, time );
110
 
        
111
 
        xmlFree( xmlTime );
112
 
        xmlFree( xmlSaid );
113
 
    }
114
 
}
115
 
 
116
 
bool Parse( const char *filename )
117
 
{
118
 
    int status;
119
 
    xmlTextReaderPtr reader = xmlNewTextReaderFilename( filename );
120
 
    if ( reader != NULL )
121
 
    {
122
 
        status = xmlTextReaderRead( reader );
123
 
        while ( status == 1 )
124
 
        {
125
 
            ProcessNode( reader );
126
 
            status = xmlTextReaderRead(reader);
127
 
        }
128
 
        xmlFreeTextReader( reader );
129
 
        
130
 
        if ( status != 0 )
131
 
        {
132
 
            std::cerr << "Parsing error\n";
133
 
            return false;
134
 
        }
135
 
    }
136
 
    else
137
 
    {
138
 
        std::cerr << "Unable to open '" << filename << "'\n";
139
 
        return false;
140
 
    }
141
 
    
142
 
    return true;
143
 
}
144
 
 
145
 
int main( int argc, const char *argv[] )
146
 
{
147
 
    if ( argc != 2 )
148
 
    {
149
 
        std::cerr << "Usage: chat_prefix_test <chat.xml>\n";
150
 
        return 1;
151
 
    }
152
 
    
153
 
    int success = Parse( argv[1] ) ? 0 : 1;
154
 
    
155
 
    std::cout << "chat_prefix_test done!\n";
156
 
    std::cout << "Statistics:\n\tNumber of sessions tested: " << Stats::stats.sessions
157
 
              << "\n\tNumber of chats: " << Stats::stats.chats
158
 
              << "\n\tNumber of chats let through: " << Stats::stats.chatsThrough
159
 
              << "\n\tNumber of chats blocked: " << Stats::stats.chats - Stats::stats.chatsThrough
160
 
              << "\n\tNumber of chat prefixes found: " << Stats::stats.foundPrefixes << "\n";
161
 
    return success;
162
 
}